text stringlengths 198 433k | conversation_id int64 0 109k |
|---|---|
Provide a correct Python 3 solution for this coding contest problem.
Artist Shinagawa was asked to exhibit n works. Therefore, I decided to exhibit the six sides of the cube colored with paint as a work. The work uses all six colors, Red, Yellow, Blue, Magenta, Green, and Cyan, and each side is filled with one color. Shinagawa changed the arrangement of colors even for cubic works with the same shape, and created n points as different works.
<image>
As a friend of mine, you, a friend of mine, allowed you to browse the work before exhibiting, and noticed that it was there. Even though they seemed to be colored differently, there were actually cubes with the same color combination. At this rate, it will not be possible to exhibit n works.
Please create a program that inputs the number of created works and the color information of each work and outputs how many more points you need to exhibit.
The color of each side of the cube is represented by the symbols from c1 to c6, and the arrangement is as follows. Also, each of c1 to c6 is one of Red, Yellow, Blue, Magenta, Green, and Cyan.
<image>
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
n
cube1
cube2
::
cuben
The first line gives the number of works n (1 ≤ n ≤ 30), and the following n lines give information on the i-th work. Information on each work is given in the following format.
c1 c2 c3 c4 c5 c6
The color arrangement ci of the work is given, separated by blanks.
The number of datasets does not exceed 100.
Output
For each dataset, output how many more works are needed to exhibit in one line.
Example
Input
3
Cyan Yellow Red Magenta Green Blue
Cyan Yellow Red Magenta Green Blue
Red Yellow Magenta Blue Green Cyan
4
Red Magenta Blue Green Yellow Cyan
Red Yellow Magenta Blue Green Cyan
Magenta Green Red Cyan Yellow Blue
Cyan Green Yellow Blue Magenta Red
0
Output
1
1
"Correct Solution:
```
def to_top_red(cube):
c1, c2, c3, c4, c5, c6 = cube
if c2 == "Red":
c1, c2, c6, c5 = c2, c6, c5, c1
elif c3 == "Red":
c1, c4, c6, c3 = c3, c1, c4, c6
elif c4 == "Red":
c1, c4, c6, c3 = c4, c6, c3, c1
elif c5 == "Red":
c1, c5, c6, c2 = c5, c6, c2, c1
elif c6 == "Red":
c1, c2, c6, c5 = c6, c5, c1, c2
return (c1, c2, c3, c4, c5, c6)
def regist(cube, cube_dic):
c1, c2, c3, c4, c5, c6 = cube
cube_dic[(c1, c2, c3, c4, c5, c6)] = True
cube_dic[(c1, c4, c2, c5, c3, c6)] = True
cube_dic[(c1, c3, c5, c2, c4, c6)] = True
cube_dic[(c1, c5, c4, c3, c2, c6)] = True
while True:
n = int(input())
if n == 0:
break
cube_dic = {}
ans = 0
for _ in range(n):
cube = to_top_red(input().split())
if cube in cube_dic:
ans += 1
else:
regist(cube, cube_dic)
print(ans)
```
| 95,200 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Artist Shinagawa was asked to exhibit n works. Therefore, I decided to exhibit the six sides of the cube colored with paint as a work. The work uses all six colors, Red, Yellow, Blue, Magenta, Green, and Cyan, and each side is filled with one color. Shinagawa changed the arrangement of colors even for cubic works with the same shape, and created n points as different works.
<image>
As a friend of mine, you, a friend of mine, allowed you to browse the work before exhibiting, and noticed that it was there. Even though they seemed to be colored differently, there were actually cubes with the same color combination. At this rate, it will not be possible to exhibit n works.
Please create a program that inputs the number of created works and the color information of each work and outputs how many more points you need to exhibit.
The color of each side of the cube is represented by the symbols from c1 to c6, and the arrangement is as follows. Also, each of c1 to c6 is one of Red, Yellow, Blue, Magenta, Green, and Cyan.
<image>
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
n
cube1
cube2
::
cuben
The first line gives the number of works n (1 ≤ n ≤ 30), and the following n lines give information on the i-th work. Information on each work is given in the following format.
c1 c2 c3 c4 c5 c6
The color arrangement ci of the work is given, separated by blanks.
The number of datasets does not exceed 100.
Output
For each dataset, output how many more works are needed to exhibit in one line.
Example
Input
3
Cyan Yellow Red Magenta Green Blue
Cyan Yellow Red Magenta Green Blue
Red Yellow Magenta Blue Green Cyan
4
Red Magenta Blue Green Yellow Cyan
Red Yellow Magenta Blue Green Cyan
Magenta Green Red Cyan Yellow Blue
Cyan Green Yellow Blue Magenta Red
0
Output
1
1
Submitted Solution:
```
roll = [
(0,1,2,3,4,5),
(3,0,2,5,4,1),
(4,1,0,3,5,2),
(1,5,2,0,4,3),
(2,1,5,3,0,4),
(5,3,2,1,4,0)]
def zero_move_to_left(xi):
r = roll[xi[0]]
return [r[i] for i in xi]
def sort_middle_face(xi):
m = xi[1:-1]
min_m = min(m)
while m[0] != min_m:
m = m[1:] + m[:1]
return xi[:1] + m + xi[-1:]
import sys
f = sys.stdin
str2i = {'Blue':0, 'Cyan':1, 'Green':2, 'Magenta':3, 'Red':4, 'Yellow':5}
import collections
while True:
n = int(f.readline())
if n == 0:
break
c = collections.Counter()
for i in range(n):
xi = [str2i[w] for w in f.readline().split()]
xi = zero_move_to_left(xi)
xi = sort_middle_face(xi)
c[tuple(xi)] += 1
print(n - len(c))
```
No
| 95,201 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Artist Shinagawa was asked to exhibit n works. Therefore, I decided to exhibit the six sides of the cube colored with paint as a work. The work uses all six colors, Red, Yellow, Blue, Magenta, Green, and Cyan, and each side is filled with one color. Shinagawa changed the arrangement of colors even for cubic works with the same shape, and created n points as different works.
<image>
As a friend of mine, you, a friend of mine, allowed you to browse the work before exhibiting, and noticed that it was there. Even though they seemed to be colored differently, there were actually cubes with the same color combination. At this rate, it will not be possible to exhibit n works.
Please create a program that inputs the number of created works and the color information of each work and outputs how many more points you need to exhibit.
The color of each side of the cube is represented by the symbols from c1 to c6, and the arrangement is as follows. Also, each of c1 to c6 is one of Red, Yellow, Blue, Magenta, Green, and Cyan.
<image>
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
n
cube1
cube2
::
cuben
The first line gives the number of works n (1 ≤ n ≤ 30), and the following n lines give information on the i-th work. Information on each work is given in the following format.
c1 c2 c3 c4 c5 c6
The color arrangement ci of the work is given, separated by blanks.
The number of datasets does not exceed 100.
Output
For each dataset, output how many more works are needed to exhibit in one line.
Example
Input
3
Cyan Yellow Red Magenta Green Blue
Cyan Yellow Red Magenta Green Blue
Red Yellow Magenta Blue Green Cyan
4
Red Magenta Blue Green Yellow Cyan
Red Yellow Magenta Blue Green Cyan
Magenta Green Red Cyan Yellow Blue
Cyan Green Yellow Blue Magenta Red
0
Output
1
1
Submitted Solution:
```
roll = [
(0,1,2,4,3,5),
(4,0,2,5,3,1),
(3,1,0,4,5,2),
(1,5,2,0,3,4),
(2,1,5,4,0,3),
(5,4,2,1,3,0)]
def zero_move_to_left(xi):
r = roll[xi[0]]
return [r[i] for i in xi]
def sort_middle_face(xi):
m = xi[1:-1]
min_m = min(m)
while m[0] != min_m:
m = [m[1],m[3],m[0],m[2]]
return xi[:1] + m + xi[-1:]
import sys
f = sys.stdin
str2i = {'Blue':0, 'Cyan':1, 'Green':2, 'Magenta':3, 'Red':4, 'Yellow':5}
import collections
while True:
n = int(f.readline())
if n == 0:
break
c = collections.Counter()
for i in range(n):
xi = [str2i[w] for w in f.readline().split()]
xi = zero_move_to_left(xi)
xi = sort_middle_face(xi)
c[tuple(xi)] += 1
print(n - len(c))
```
No
| 95,202 |
Provide a correct Python 3 solution for this coding contest problem.
Alice and Brown are brothers in a family and each receives pocket money in celebration of the coming year. They are very close and share the total amount of the money fifty-fifty. The pocket money each receives is a multiple of 1,000 yen.
Write a program to calculate each one’s share given the amount of money Alice and Brown received.
Input
The input is given in the following format.
a b
A line of data is given that contains two values of money: a (1000 ≤ a ≤ 50000) for Alice and b (1000 ≤ b ≤ 50000) for Brown.
Output
Output the amount of money each of Alice and Brown receive in a line.
Examples
Input
1000 3000
Output
2000
Input
5000 5000
Output
5000
Input
1000 2000
Output
1500
"Correct Solution:
```
a,b=map(int,input().split())
n=(a+b)//2 #//と/の違い
print(n)
```
| 95,203 |
Provide a correct Python 3 solution for this coding contest problem.
Alice and Brown are brothers in a family and each receives pocket money in celebration of the coming year. They are very close and share the total amount of the money fifty-fifty. The pocket money each receives is a multiple of 1,000 yen.
Write a program to calculate each one’s share given the amount of money Alice and Brown received.
Input
The input is given in the following format.
a b
A line of data is given that contains two values of money: a (1000 ≤ a ≤ 50000) for Alice and b (1000 ≤ b ≤ 50000) for Brown.
Output
Output the amount of money each of Alice and Brown receive in a line.
Examples
Input
1000 3000
Output
2000
Input
5000 5000
Output
5000
Input
1000 2000
Output
1500
"Correct Solution:
```
a,b=map(int,input().split())
s=int((a+b)/2)
print(s)
```
| 95,204 |
Provide a correct Python 3 solution for this coding contest problem.
Alice and Brown are brothers in a family and each receives pocket money in celebration of the coming year. They are very close and share the total amount of the money fifty-fifty. The pocket money each receives is a multiple of 1,000 yen.
Write a program to calculate each one’s share given the amount of money Alice and Brown received.
Input
The input is given in the following format.
a b
A line of data is given that contains two values of money: a (1000 ≤ a ≤ 50000) for Alice and b (1000 ≤ b ≤ 50000) for Brown.
Output
Output the amount of money each of Alice and Brown receive in a line.
Examples
Input
1000 3000
Output
2000
Input
5000 5000
Output
5000
Input
1000 2000
Output
1500
"Correct Solution:
```
a,b=(int(x) for x in input().split())
print((a+b)//2)
```
| 95,205 |
Provide a correct Python 3 solution for this coding contest problem.
Alice and Brown are brothers in a family and each receives pocket money in celebration of the coming year. They are very close and share the total amount of the money fifty-fifty. The pocket money each receives is a multiple of 1,000 yen.
Write a program to calculate each one’s share given the amount of money Alice and Brown received.
Input
The input is given in the following format.
a b
A line of data is given that contains two values of money: a (1000 ≤ a ≤ 50000) for Alice and b (1000 ≤ b ≤ 50000) for Brown.
Output
Output the amount of money each of Alice and Brown receive in a line.
Examples
Input
1000 3000
Output
2000
Input
5000 5000
Output
5000
Input
1000 2000
Output
1500
"Correct Solution:
```
a , b , = map(int , input() . split())
c = (a + b) / 2
print(int(c))
```
| 95,206 |
Provide a correct Python 3 solution for this coding contest problem.
Alice and Brown are brothers in a family and each receives pocket money in celebration of the coming year. They are very close and share the total amount of the money fifty-fifty. The pocket money each receives is a multiple of 1,000 yen.
Write a program to calculate each one’s share given the amount of money Alice and Brown received.
Input
The input is given in the following format.
a b
A line of data is given that contains two values of money: a (1000 ≤ a ≤ 50000) for Alice and b (1000 ≤ b ≤ 50000) for Brown.
Output
Output the amount of money each of Alice and Brown receive in a line.
Examples
Input
1000 3000
Output
2000
Input
5000 5000
Output
5000
Input
1000 2000
Output
1500
"Correct Solution:
```
# coding=utf-8
a, b = map(int, input().split())
print((a+b)//2)
```
| 95,207 |
Provide a correct Python 3 solution for this coding contest problem.
Alice and Brown are brothers in a family and each receives pocket money in celebration of the coming year. They are very close and share the total amount of the money fifty-fifty. The pocket money each receives is a multiple of 1,000 yen.
Write a program to calculate each one’s share given the amount of money Alice and Brown received.
Input
The input is given in the following format.
a b
A line of data is given that contains two values of money: a (1000 ≤ a ≤ 50000) for Alice and b (1000 ≤ b ≤ 50000) for Brown.
Output
Output the amount of money each of Alice and Brown receive in a line.
Examples
Input
1000 3000
Output
2000
Input
5000 5000
Output
5000
Input
1000 2000
Output
1500
"Correct Solution:
```
# coding: utf-8
# Your code here!
a,b=map(int,input().split())
print(int((a+b)/2))
```
| 95,208 |
Provide a correct Python 3 solution for this coding contest problem.
Alice and Brown are brothers in a family and each receives pocket money in celebration of the coming year. They are very close and share the total amount of the money fifty-fifty. The pocket money each receives is a multiple of 1,000 yen.
Write a program to calculate each one’s share given the amount of money Alice and Brown received.
Input
The input is given in the following format.
a b
A line of data is given that contains two values of money: a (1000 ≤ a ≤ 50000) for Alice and b (1000 ≤ b ≤ 50000) for Brown.
Output
Output the amount of money each of Alice and Brown receive in a line.
Examples
Input
1000 3000
Output
2000
Input
5000 5000
Output
5000
Input
1000 2000
Output
1500
"Correct Solution:
```
a,b=map(int,input().split())
print(round((a+b)/2))
```
| 95,209 |
Provide a correct Python 3 solution for this coding contest problem.
Alice and Brown are brothers in a family and each receives pocket money in celebration of the coming year. They are very close and share the total amount of the money fifty-fifty. The pocket money each receives is a multiple of 1,000 yen.
Write a program to calculate each one’s share given the amount of money Alice and Brown received.
Input
The input is given in the following format.
a b
A line of data is given that contains two values of money: a (1000 ≤ a ≤ 50000) for Alice and b (1000 ≤ b ≤ 50000) for Brown.
Output
Output the amount of money each of Alice and Brown receive in a line.
Examples
Input
1000 3000
Output
2000
Input
5000 5000
Output
5000
Input
1000 2000
Output
1500
"Correct Solution:
```
a, b = [int(x) for x in input().split()]
print((a+b)//2)
```
| 95,210 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice and Brown are brothers in a family and each receives pocket money in celebration of the coming year. They are very close and share the total amount of the money fifty-fifty. The pocket money each receives is a multiple of 1,000 yen.
Write a program to calculate each one’s share given the amount of money Alice and Brown received.
Input
The input is given in the following format.
a b
A line of data is given that contains two values of money: a (1000 ≤ a ≤ 50000) for Alice and b (1000 ≤ b ≤ 50000) for Brown.
Output
Output the amount of money each of Alice and Brown receive in a line.
Examples
Input
1000 3000
Output
2000
Input
5000 5000
Output
5000
Input
1000 2000
Output
1500
Submitted Solution:
```
a,b = input().split()
a = int(a)
b = int(b)
c = (a + b) /2
print(int(c))
```
Yes
| 95,211 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice and Brown are brothers in a family and each receives pocket money in celebration of the coming year. They are very close and share the total amount of the money fifty-fifty. The pocket money each receives is a multiple of 1,000 yen.
Write a program to calculate each one’s share given the amount of money Alice and Brown received.
Input
The input is given in the following format.
a b
A line of data is given that contains two values of money: a (1000 ≤ a ≤ 50000) for Alice and b (1000 ≤ b ≤ 50000) for Brown.
Output
Output the amount of money each of Alice and Brown receive in a line.
Examples
Input
1000 3000
Output
2000
Input
5000 5000
Output
5000
Input
1000 2000
Output
1500
Submitted Solution:
```
def main():
a,b = map(int, input().split())
print(int((a + b) / 2))
if __name__ == "__main__":
main()
```
Yes
| 95,212 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice and Brown are brothers in a family and each receives pocket money in celebration of the coming year. They are very close and share the total amount of the money fifty-fifty. The pocket money each receives is a multiple of 1,000 yen.
Write a program to calculate each one’s share given the amount of money Alice and Brown received.
Input
The input is given in the following format.
a b
A line of data is given that contains two values of money: a (1000 ≤ a ≤ 50000) for Alice and b (1000 ≤ b ≤ 50000) for Brown.
Output
Output the amount of money each of Alice and Brown receive in a line.
Examples
Input
1000 3000
Output
2000
Input
5000 5000
Output
5000
Input
1000 2000
Output
1500
Submitted Solution:
```
a,b=map(int,input().split())
s=a + b
y=s/2
print(int(y))
```
Yes
| 95,213 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice and Brown are brothers in a family and each receives pocket money in celebration of the coming year. They are very close and share the total amount of the money fifty-fifty. The pocket money each receives is a multiple of 1,000 yen.
Write a program to calculate each one’s share given the amount of money Alice and Brown received.
Input
The input is given in the following format.
a b
A line of data is given that contains two values of money: a (1000 ≤ a ≤ 50000) for Alice and b (1000 ≤ b ≤ 50000) for Brown.
Output
Output the amount of money each of Alice and Brown receive in a line.
Examples
Input
1000 3000
Output
2000
Input
5000 5000
Output
5000
Input
1000 2000
Output
1500
Submitted Solution:
```
a,b=map(int, input().split())
print("%d" % ((a+b)/2))
```
Yes
| 95,214 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice and Brown are brothers in a family and each receives pocket money in celebration of the coming year. They are very close and share the total amount of the money fifty-fifty. The pocket money each receives is a multiple of 1,000 yen.
Write a program to calculate each one’s share given the amount of money Alice and Brown received.
Input
The input is given in the following format.
a b
A line of data is given that contains two values of money: a (1000 ≤ a ≤ 50000) for Alice and b (1000 ≤ b ≤ 50000) for Brown.
Output
Output the amount of money each of Alice and Brown receive in a line.
Examples
Input
1000 3000
Output
2000
Input
5000 5000
Output
5000
Input
1000 2000
Output
1500
Submitted Solution:
```
inp = input().split(" ")
print(inp)
```
No
| 95,215 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice and Brown are brothers in a family and each receives pocket money in celebration of the coming year. They are very close and share the total amount of the money fifty-fifty. The pocket money each receives is a multiple of 1,000 yen.
Write a program to calculate each one’s share given the amount of money Alice and Brown received.
Input
The input is given in the following format.
a b
A line of data is given that contains two values of money: a (1000 ≤ a ≤ 50000) for Alice and b (1000 ≤ b ≤ 50000) for Brown.
Output
Output the amount of money each of Alice and Brown receive in a line.
Examples
Input
1000 3000
Output
2000
Input
5000 5000
Output
5000
Input
1000 2000
Output
1500
Submitted Solution:
```
a,b = map(int,input())
print((a+b)//2)
```
No
| 95,216 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice and Brown are brothers in a family and each receives pocket money in celebration of the coming year. They are very close and share the total amount of the money fifty-fifty. The pocket money each receives is a multiple of 1,000 yen.
Write a program to calculate each one’s share given the amount of money Alice and Brown received.
Input
The input is given in the following format.
a b
A line of data is given that contains two values of money: a (1000 ≤ a ≤ 50000) for Alice and b (1000 ≤ b ≤ 50000) for Brown.
Output
Output the amount of money each of Alice and Brown receive in a line.
Examples
Input
1000 3000
Output
2000
Input
5000 5000
Output
5000
Input
1000 2000
Output
1500
Submitted Solution:
```
a, b = input().split(" ")
a = int(a)
b = int(b)
print(a / b)
```
No
| 95,217 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice and Brown are brothers in a family and each receives pocket money in celebration of the coming year. They are very close and share the total amount of the money fifty-fifty. The pocket money each receives is a multiple of 1,000 yen.
Write a program to calculate each one’s share given the amount of money Alice and Brown received.
Input
The input is given in the following format.
a b
A line of data is given that contains two values of money: a (1000 ≤ a ≤ 50000) for Alice and b (1000 ≤ b ≤ 50000) for Brown.
Output
Output the amount of money each of Alice and Brown receive in a line.
Examples
Input
1000 3000
Output
2000
Input
5000 5000
Output
5000
Input
1000 2000
Output
1500
Submitted Solution:
```
print(sum(map(int,input().split()))/2)
```
No
| 95,218 |
Provide a correct Python 3 solution for this coding contest problem.
In the Kingdom of IOI, the wind always blows from sea to land. There are $N + 1$ spots numbered from $0$ to $N$. The wind from Spot $0$ to Spot $N$ in order. Mr. JOI has a house at Spot $N$. The altitude of Spot $0$ is $A_0 = 0$, and the altitude of Spot $i$ ($1 \leq i \leq N$) is $A_i$.
The wind blows on the surface of the ground. The temperature of the wind changes according to the change of the altitude. The temperature of the wind at Spot $0$, which is closest to the sea, is $0$ degree. For each $i$ ($0 \leq i \leq N - 1$), the change of the temperature of the wind from Spot $i$ to Spot $i + 1$ depends only on the values of $A_i$ and $A_{i+1}$ in the following way:
* If $A_i < A_{i+1}$, the temperature of the wind decreases by $S$ degrees per altitude.
* If $A_i \geq A_{i+1}$, the temperature of the wind increases by $T$ degrees per altitude.
The tectonic movement is active in the land of the Kingdom of IOI. You have the data of tectonic movements for $Q$ days. In the $j$-th ($1 \leq j \leq Q$) day, the change of the altitude of Spot $k$ for $L_j \leq k \leq R_j$ ($1 \leq L_j \leq R_j \leq N$) is described by $X_j$. If $X_j$ is not negative, the altitude increases by $X_j$. If $X_j$ is negative, the altitude decreases by $|X_j|$.
Your task is to calculate the temperature of the wind at the house of Mr. JOI after each tectonic movement.
Task
Given the data of tectonic movements, write a program which calculates, for each $j$ ($1 \leq j \leq Q$), the temperature of the wind at the house of Mr. JOI after the tectonic movement on the $j$-th day.
Input
Read the following data from the standard input.
* The first line of input contains four space separated integers $N$, $Q$, $S$, $T$. This means there is a house of Mr. JOI at Spot $N$, there are $Q$ tectonic movements, the temperature of the wind decreases by $S$ degrees per altitude if the altitude increases, and the temperature of the wind increases by $T$ degrees per altitude if the altitude decreases.
* The $i$-th line ($1 \leq i \leq N +1$) of the following $N +1$ lines contains an integer $A_{i-1}$, which is the initial altitude at Spot ($i - 1$) before tectonic movements.
* The $j$-th line ($1 \leq j \leq Q$) of the following $Q$ lines contains three space separated integers $L_j$, $R_j$, $X_j$. This means, for the tectonic movement on the $j$-th day, the change of the altitude at the spots from $L_j$ to $R_j$ is described by $X_j$.
Output
Write $Q$ lines to the standard output. The $j$-th line ($1 \leq j \leq Q$) of output contains the temperature of the wind at the house of Mr. JOI after the tectonic movement on the $j$-th day.
Constraints
All input data satisfy the following conditions.
* $1 \leq N \leq 200 000．$
* $1 \leq Q \leq 200 000．$
* $1 \leq S \leq 1 000 000．$
* $1 \leq T \leq 1 000 000．$
* $A_0 = 0．$
* $-1 000 000 \leq A_i \leq 1 000 000 (1 \leq i \leq N)．$
* $1 \leq L_j \leq R_j \leq N (1 \leq j \leq Q)．$
* $ -1 000 000 \leq X_j \leq 1 000 000 (1 \leq j \leq Q)．$
Sample Input and Output
Sample Input 1
3 5 1 2
0
4
1
8
1 2 2
1 1 -2
2 3 5
1 2 -1
1 3 5
Sample Output 1
-5
-7
-13
-13
-18
Initially, the altitudes of the Spot 0, 1, 2, 3 are 0, 4, 1, 8, respectively. After the tectonic movement on the first day, the altitudes become 0, 6, 3, 8, respectively. At that moment, the temperatures of the wind are 0, -6, 0, -5,respectively.
Sample Input 2
2 2 5 5
0
6
-1
1 1 4
1 2 8
Sample Output 2
5
-35
Sample Input 3
7 8 8 13
0
4
-9
4
-2
3
10
-9
1 4 8
3 5 -2
3 3 9
1 7 4
3 5 -1
5 6 3
4 4 9
6 7 -10
Sample output 3
277
277
322
290
290
290
290
370
Creatie Commons License
The 16th Japanese Olympiad in Informatics (JOI 2016/2017) Final Round
Example
Input
3 5 1 2
0
4
1
8
1 2 2
1 1 -2
2 3 5
1 2 -1
1 3 5
Output
-5
-7
-13
-13
-18
"Correct Solution:
```
N, Q, S, T = map(int, input().split())
A = [int(input()) for i in range(N+1)]
C = 0
for i in range(N):
if A[i] < A[i+1]:
C += S * (A[i] - A[i+1])
else:
C += T * (A[i] - A[i+1])
def add(k, x):
if x >= 0:
if B[k] <= 0:
if B[k] + x <= 0:
return - T * x
return T * B[k] - S * (B[k] + x)
return - S * x
if B[k] >= 0:
if B[k] + x >= 0:
return - S * x
return S * B[k] - T * (B[k] + x)
return - T * x
B = [A[i+1] - A[i] for i in range(N)]
ans = []
for q in range(Q):
l, r, x = map(int, input().split())
C += add(l-1, x); B[l-1] += x
if r < N:
C += add(r, -x); B[r] -= x
ans.append(C)
print(*ans, sep='\n')
```
| 95,219 |
Provide a correct Python 3 solution for this coding contest problem.
In the Kingdom of IOI, the wind always blows from sea to land. There are $N + 1$ spots numbered from $0$ to $N$. The wind from Spot $0$ to Spot $N$ in order. Mr. JOI has a house at Spot $N$. The altitude of Spot $0$ is $A_0 = 0$, and the altitude of Spot $i$ ($1 \leq i \leq N$) is $A_i$.
The wind blows on the surface of the ground. The temperature of the wind changes according to the change of the altitude. The temperature of the wind at Spot $0$, which is closest to the sea, is $0$ degree. For each $i$ ($0 \leq i \leq N - 1$), the change of the temperature of the wind from Spot $i$ to Spot $i + 1$ depends only on the values of $A_i$ and $A_{i+1}$ in the following way:
* If $A_i < A_{i+1}$, the temperature of the wind decreases by $S$ degrees per altitude.
* If $A_i \geq A_{i+1}$, the temperature of the wind increases by $T$ degrees per altitude.
The tectonic movement is active in the land of the Kingdom of IOI. You have the data of tectonic movements for $Q$ days. In the $j$-th ($1 \leq j \leq Q$) day, the change of the altitude of Spot $k$ for $L_j \leq k \leq R_j$ ($1 \leq L_j \leq R_j \leq N$) is described by $X_j$. If $X_j$ is not negative, the altitude increases by $X_j$. If $X_j$ is negative, the altitude decreases by $|X_j|$.
Your task is to calculate the temperature of the wind at the house of Mr. JOI after each tectonic movement.
Task
Given the data of tectonic movements, write a program which calculates, for each $j$ ($1 \leq j \leq Q$), the temperature of the wind at the house of Mr. JOI after the tectonic movement on the $j$-th day.
Input
Read the following data from the standard input.
* The first line of input contains four space separated integers $N$, $Q$, $S$, $T$. This means there is a house of Mr. JOI at Spot $N$, there are $Q$ tectonic movements, the temperature of the wind decreases by $S$ degrees per altitude if the altitude increases, and the temperature of the wind increases by $T$ degrees per altitude if the altitude decreases.
* The $i$-th line ($1 \leq i \leq N +1$) of the following $N +1$ lines contains an integer $A_{i-1}$, which is the initial altitude at Spot ($i - 1$) before tectonic movements.
* The $j$-th line ($1 \leq j \leq Q$) of the following $Q$ lines contains three space separated integers $L_j$, $R_j$, $X_j$. This means, for the tectonic movement on the $j$-th day, the change of the altitude at the spots from $L_j$ to $R_j$ is described by $X_j$.
Output
Write $Q$ lines to the standard output. The $j$-th line ($1 \leq j \leq Q$) of output contains the temperature of the wind at the house of Mr. JOI after the tectonic movement on the $j$-th day.
Constraints
All input data satisfy the following conditions.
* $1 \leq N \leq 200 000．$
* $1 \leq Q \leq 200 000．$
* $1 \leq S \leq 1 000 000．$
* $1 \leq T \leq 1 000 000．$
* $A_0 = 0．$
* $-1 000 000 \leq A_i \leq 1 000 000 (1 \leq i \leq N)．$
* $1 \leq L_j \leq R_j \leq N (1 \leq j \leq Q)．$
* $ -1 000 000 \leq X_j \leq 1 000 000 (1 \leq j \leq Q)．$
Sample Input and Output
Sample Input 1
3 5 1 2
0
4
1
8
1 2 2
1 1 -2
2 3 5
1 2 -1
1 3 5
Sample Output 1
-5
-7
-13
-13
-18
Initially, the altitudes of the Spot 0, 1, 2, 3 are 0, 4, 1, 8, respectively. After the tectonic movement on the first day, the altitudes become 0, 6, 3, 8, respectively. At that moment, the temperatures of the wind are 0, -6, 0, -5,respectively.
Sample Input 2
2 2 5 5
0
6
-1
1 1 4
1 2 8
Sample Output 2
5
-35
Sample Input 3
7 8 8 13
0
4
-9
4
-2
3
10
-9
1 4 8
3 5 -2
3 3 9
1 7 4
3 5 -1
5 6 3
4 4 9
6 7 -10
Sample output 3
277
277
322
290
290
290
290
370
Creatie Commons License
The 16th Japanese Olympiad in Informatics (JOI 2016/2017) Final Round
Example
Input
3 5 1 2
0
4
1
8
1 2 2
1 1 -2
2 3 5
1 2 -1
1 3 5
Output
-5
-7
-13
-13
-18
"Correct Solution:
```
N, Q, S, T = map(int, input().split())
A = [int(input()) for i in range(N + 1)]
diff = [A[i + 1] - A[i] for i in range(N)]
def calc(v):
if v > 0:
return -S * v
else:
return -T * v
ret = 0
for i in range(N):
ret += calc(diff[i])
for i in range(Q):
a, b, c = map(int, input().split())
ret -= calc(diff[a - 1])
diff[a - 1] += c
ret += calc(diff[a - 1])
if b != N:
ret -= calc(diff[b])
diff[b] -= c
ret += calc(diff[b])
print(ret)
```
| 95,220 |
Provide a correct Python 3 solution for this coding contest problem.
In the Kingdom of IOI, the wind always blows from sea to land. There are $N + 1$ spots numbered from $0$ to $N$. The wind from Spot $0$ to Spot $N$ in order. Mr. JOI has a house at Spot $N$. The altitude of Spot $0$ is $A_0 = 0$, and the altitude of Spot $i$ ($1 \leq i \leq N$) is $A_i$.
The wind blows on the surface of the ground. The temperature of the wind changes according to the change of the altitude. The temperature of the wind at Spot $0$, which is closest to the sea, is $0$ degree. For each $i$ ($0 \leq i \leq N - 1$), the change of the temperature of the wind from Spot $i$ to Spot $i + 1$ depends only on the values of $A_i$ and $A_{i+1}$ in the following way:
* If $A_i < A_{i+1}$, the temperature of the wind decreases by $S$ degrees per altitude.
* If $A_i \geq A_{i+1}$, the temperature of the wind increases by $T$ degrees per altitude.
The tectonic movement is active in the land of the Kingdom of IOI. You have the data of tectonic movements for $Q$ days. In the $j$-th ($1 \leq j \leq Q$) day, the change of the altitude of Spot $k$ for $L_j \leq k \leq R_j$ ($1 \leq L_j \leq R_j \leq N$) is described by $X_j$. If $X_j$ is not negative, the altitude increases by $X_j$. If $X_j$ is negative, the altitude decreases by $|X_j|$.
Your task is to calculate the temperature of the wind at the house of Mr. JOI after each tectonic movement.
Task
Given the data of tectonic movements, write a program which calculates, for each $j$ ($1 \leq j \leq Q$), the temperature of the wind at the house of Mr. JOI after the tectonic movement on the $j$-th day.
Input
Read the following data from the standard input.
* The first line of input contains four space separated integers $N$, $Q$, $S$, $T$. This means there is a house of Mr. JOI at Spot $N$, there are $Q$ tectonic movements, the temperature of the wind decreases by $S$ degrees per altitude if the altitude increases, and the temperature of the wind increases by $T$ degrees per altitude if the altitude decreases.
* The $i$-th line ($1 \leq i \leq N +1$) of the following $N +1$ lines contains an integer $A_{i-1}$, which is the initial altitude at Spot ($i - 1$) before tectonic movements.
* The $j$-th line ($1 \leq j \leq Q$) of the following $Q$ lines contains three space separated integers $L_j$, $R_j$, $X_j$. This means, for the tectonic movement on the $j$-th day, the change of the altitude at the spots from $L_j$ to $R_j$ is described by $X_j$.
Output
Write $Q$ lines to the standard output. The $j$-th line ($1 \leq j \leq Q$) of output contains the temperature of the wind at the house of Mr. JOI after the tectonic movement on the $j$-th day.
Constraints
All input data satisfy the following conditions.
* $1 \leq N \leq 200 000．$
* $1 \leq Q \leq 200 000．$
* $1 \leq S \leq 1 000 000．$
* $1 \leq T \leq 1 000 000．$
* $A_0 = 0．$
* $-1 000 000 \leq A_i \leq 1 000 000 (1 \leq i \leq N)．$
* $1 \leq L_j \leq R_j \leq N (1 \leq j \leq Q)．$
* $ -1 000 000 \leq X_j \leq 1 000 000 (1 \leq j \leq Q)．$
Sample Input and Output
Sample Input 1
3 5 1 2
0
4
1
8
1 2 2
1 1 -2
2 3 5
1 2 -1
1 3 5
Sample Output 1
-5
-7
-13
-13
-18
Initially, the altitudes of the Spot 0, 1, 2, 3 are 0, 4, 1, 8, respectively. After the tectonic movement on the first day, the altitudes become 0, 6, 3, 8, respectively. At that moment, the temperatures of the wind are 0, -6, 0, -5,respectively.
Sample Input 2
2 2 5 5
0
6
-1
1 1 4
1 2 8
Sample Output 2
5
-35
Sample Input 3
7 8 8 13
0
4
-9
4
-2
3
10
-9
1 4 8
3 5 -2
3 3 9
1 7 4
3 5 -1
5 6 3
4 4 9
6 7 -10
Sample output 3
277
277
322
290
290
290
290
370
Creatie Commons License
The 16th Japanese Olympiad in Informatics (JOI 2016/2017) Final Round
Example
Input
3 5 1 2
0
4
1
8
1 2 2
1 1 -2
2 3 5
1 2 -1
1 3 5
Output
-5
-7
-13
-13
-18
"Correct Solution:
```
n, q, s, t = map(int, input().split())
a_lst = [int(input()) for _ in range(n + 1)]
diff = [a_lst[i + 1] - a_lst[i] for i in range(n)]
temp = sum([-d * s if d > 0 else -d * t for d in diff])
def score(d):
if d > 0:
return -s * d
else:
return -t * d
for _ in range(q):
l, r, x = map(int, input().split())
a = diff[l - 1]
diff[l - 1] += x
temp += score(diff[l - 1]) - score(a)
if r < n:
b = diff[r]
diff[r] -= x
temp += score(diff[r]) - score(b)
print(temp)
```
| 95,221 |
Provide a correct Python 3 solution for this coding contest problem.
In the Kingdom of IOI, the wind always blows from sea to land. There are $N + 1$ spots numbered from $0$ to $N$. The wind from Spot $0$ to Spot $N$ in order. Mr. JOI has a house at Spot $N$. The altitude of Spot $0$ is $A_0 = 0$, and the altitude of Spot $i$ ($1 \leq i \leq N$) is $A_i$.
The wind blows on the surface of the ground. The temperature of the wind changes according to the change of the altitude. The temperature of the wind at Spot $0$, which is closest to the sea, is $0$ degree. For each $i$ ($0 \leq i \leq N - 1$), the change of the temperature of the wind from Spot $i$ to Spot $i + 1$ depends only on the values of $A_i$ and $A_{i+1}$ in the following way:
* If $A_i < A_{i+1}$, the temperature of the wind decreases by $S$ degrees per altitude.
* If $A_i \geq A_{i+1}$, the temperature of the wind increases by $T$ degrees per altitude.
The tectonic movement is active in the land of the Kingdom of IOI. You have the data of tectonic movements for $Q$ days. In the $j$-th ($1 \leq j \leq Q$) day, the change of the altitude of Spot $k$ for $L_j \leq k \leq R_j$ ($1 \leq L_j \leq R_j \leq N$) is described by $X_j$. If $X_j$ is not negative, the altitude increases by $X_j$. If $X_j$ is negative, the altitude decreases by $|X_j|$.
Your task is to calculate the temperature of the wind at the house of Mr. JOI after each tectonic movement.
Task
Given the data of tectonic movements, write a program which calculates, for each $j$ ($1 \leq j \leq Q$), the temperature of the wind at the house of Mr. JOI after the tectonic movement on the $j$-th day.
Input
Read the following data from the standard input.
* The first line of input contains four space separated integers $N$, $Q$, $S$, $T$. This means there is a house of Mr. JOI at Spot $N$, there are $Q$ tectonic movements, the temperature of the wind decreases by $S$ degrees per altitude if the altitude increases, and the temperature of the wind increases by $T$ degrees per altitude if the altitude decreases.
* The $i$-th line ($1 \leq i \leq N +1$) of the following $N +1$ lines contains an integer $A_{i-1}$, which is the initial altitude at Spot ($i - 1$) before tectonic movements.
* The $j$-th line ($1 \leq j \leq Q$) of the following $Q$ lines contains three space separated integers $L_j$, $R_j$, $X_j$. This means, for the tectonic movement on the $j$-th day, the change of the altitude at the spots from $L_j$ to $R_j$ is described by $X_j$.
Output
Write $Q$ lines to the standard output. The $j$-th line ($1 \leq j \leq Q$) of output contains the temperature of the wind at the house of Mr. JOI after the tectonic movement on the $j$-th day.
Constraints
All input data satisfy the following conditions.
* $1 \leq N \leq 200 000．$
* $1 \leq Q \leq 200 000．$
* $1 \leq S \leq 1 000 000．$
* $1 \leq T \leq 1 000 000．$
* $A_0 = 0．$
* $-1 000 000 \leq A_i \leq 1 000 000 (1 \leq i \leq N)．$
* $1 \leq L_j \leq R_j \leq N (1 \leq j \leq Q)．$
* $ -1 000 000 \leq X_j \leq 1 000 000 (1 \leq j \leq Q)．$
Sample Input and Output
Sample Input 1
3 5 1 2
0
4
1
8
1 2 2
1 1 -2
2 3 5
1 2 -1
1 3 5
Sample Output 1
-5
-7
-13
-13
-18
Initially, the altitudes of the Spot 0, 1, 2, 3 are 0, 4, 1, 8, respectively. After the tectonic movement on the first day, the altitudes become 0, 6, 3, 8, respectively. At that moment, the temperatures of the wind are 0, -6, 0, -5,respectively.
Sample Input 2
2 2 5 5
0
6
-1
1 1 4
1 2 8
Sample Output 2
5
-35
Sample Input 3
7 8 8 13
0
4
-9
4
-2
3
10
-9
1 4 8
3 5 -2
3 3 9
1 7 4
3 5 -1
5 6 3
4 4 9
6 7 -10
Sample output 3
277
277
322
290
290
290
290
370
Creatie Commons License
The 16th Japanese Olympiad in Informatics (JOI 2016/2017) Final Round
Example
Input
3 5 1 2
0
4
1
8
1 2 2
1 1 -2
2 3 5
1 2 -1
1 3 5
Output
-5
-7
-13
-13
-18
"Correct Solution:
```
n, q, s, t = map(int, input().split())
a = [int(input()) for _ in range(n + 1)]
for i in range(1, n + 1)[::-1]:
a[i] -= a[i - 1]
count = 0
for i in range(n + 1):
count -= a[i] * s if a[i] > 0 else a[i] * t
for _ in range(q):
l, r, x = map(int, input().split())
count += a[l] * s if a[l] > 0 else a[l] * t
a[l] += x
count -= a[l] * s if a[l] > 0 else a[l] * t
if r < n:
count += a[r + 1] * s if a[r + 1] > 0 else a[r + 1] * t
a[r + 1] -= x
count -= a[r + 1] * s if a[r + 1] > 0 else a[r + 1] * t
print(count)
```
| 95,222 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the Kingdom of IOI, the wind always blows from sea to land. There are $N + 1$ spots numbered from $0$ to $N$. The wind from Spot $0$ to Spot $N$ in order. Mr. JOI has a house at Spot $N$. The altitude of Spot $0$ is $A_0 = 0$, and the altitude of Spot $i$ ($1 \leq i \leq N$) is $A_i$.
The wind blows on the surface of the ground. The temperature of the wind changes according to the change of the altitude. The temperature of the wind at Spot $0$, which is closest to the sea, is $0$ degree. For each $i$ ($0 \leq i \leq N - 1$), the change of the temperature of the wind from Spot $i$ to Spot $i + 1$ depends only on the values of $A_i$ and $A_{i+1}$ in the following way:
* If $A_i < A_{i+1}$, the temperature of the wind decreases by $S$ degrees per altitude.
* If $A_i \geq A_{i+1}$, the temperature of the wind increases by $T$ degrees per altitude.
The tectonic movement is active in the land of the Kingdom of IOI. You have the data of tectonic movements for $Q$ days. In the $j$-th ($1 \leq j \leq Q$) day, the change of the altitude of Spot $k$ for $L_j \leq k \leq R_j$ ($1 \leq L_j \leq R_j \leq N$) is described by $X_j$. If $X_j$ is not negative, the altitude increases by $X_j$. If $X_j$ is negative, the altitude decreases by $|X_j|$.
Your task is to calculate the temperature of the wind at the house of Mr. JOI after each tectonic movement.
Task
Given the data of tectonic movements, write a program which calculates, for each $j$ ($1 \leq j \leq Q$), the temperature of the wind at the house of Mr. JOI after the tectonic movement on the $j$-th day.
Input
Read the following data from the standard input.
* The first line of input contains four space separated integers $N$, $Q$, $S$, $T$. This means there is a house of Mr. JOI at Spot $N$, there are $Q$ tectonic movements, the temperature of the wind decreases by $S$ degrees per altitude if the altitude increases, and the temperature of the wind increases by $T$ degrees per altitude if the altitude decreases.
* The $i$-th line ($1 \leq i \leq N +1$) of the following $N +1$ lines contains an integer $A_{i-1}$, which is the initial altitude at Spot ($i - 1$) before tectonic movements.
* The $j$-th line ($1 \leq j \leq Q$) of the following $Q$ lines contains three space separated integers $L_j$, $R_j$, $X_j$. This means, for the tectonic movement on the $j$-th day, the change of the altitude at the spots from $L_j$ to $R_j$ is described by $X_j$.
Output
Write $Q$ lines to the standard output. The $j$-th line ($1 \leq j \leq Q$) of output contains the temperature of the wind at the house of Mr. JOI after the tectonic movement on the $j$-th day.
Constraints
All input data satisfy the following conditions.
* $1 \leq N \leq 200 000．$
* $1 \leq Q \leq 200 000．$
* $1 \leq S \leq 1 000 000．$
* $1 \leq T \leq 1 000 000．$
* $A_0 = 0．$
* $-1 000 000 \leq A_i \leq 1 000 000 (1 \leq i \leq N)．$
* $1 \leq L_j \leq R_j \leq N (1 \leq j \leq Q)．$
* $ -1 000 000 \leq X_j \leq 1 000 000 (1 \leq j \leq Q)．$
Sample Input and Output
Sample Input 1
3 5 1 2
0
4
1
8
1 2 2
1 1 -2
2 3 5
1 2 -1
1 3 5
Sample Output 1
-5
-7
-13
-13
-18
Initially, the altitudes of the Spot 0, 1, 2, 3 are 0, 4, 1, 8, respectively. After the tectonic movement on the first day, the altitudes become 0, 6, 3, 8, respectively. At that moment, the temperatures of the wind are 0, -6, 0, -5,respectively.
Sample Input 2
2 2 5 5
0
6
-1
1 1 4
1 2 8
Sample Output 2
5
-35
Sample Input 3
7 8 8 13
0
4
-9
4
-2
3
10
-9
1 4 8
3 5 -2
3 3 9
1 7 4
3 5 -1
5 6 3
4 4 9
6 7 -10
Sample output 3
277
277
322
290
290
290
290
370
Creatie Commons License
The 16th Japanese Olympiad in Informatics (JOI 2016/2017) Final Round
Example
Input
3 5 1 2
0
4
1
8
1 2 2
1 1 -2
2 3 5
1 2 -1
1 3 5
Output
-5
-7
-13
-13
-18
Submitted Solution:
```
n, q, s, t = map(int, input().split())
a = [int(input()) for _ in range(n + 1)]
for _ in range(q):
l, r, x = map(int, input().split())
for i in range(l, r + 1):
a[i] += x
temp = 0
for i in range(1, n + 1):
temp += (a[i - 1] - a[i]) * s if a[i] > a[i - 1] else (a[i - 1] - a[i]) * t
print(temp)
```
No
| 95,223 |
Provide a correct Python 3 solution for this coding contest problem.
A fraction whose numerator is 1 and whose denominator is a positive integer is called a unit fraction. A representation of a positive rational number p/q as the sum of finitely many unit fractions is called a partition of p/q into unit fractions. For example, 1/2 + 1/6 is a partition of 2/3 into unit fractions. The difference in the order of addition is disregarded. For example, we do not distinguish 1/6 + 1/2 from 1/2 + 1/6.
For given four positive integers p, q, a, and n, count the number of partitions of p/q into unit fractions satisfying the following two conditions.
* The partition is the sum of at most n many unit fractions.
* The product of the denominators of the unit fractions in the partition is less than or equal to a.
For example, if (p,q,a,n) = (2,3,120,3), you should report 4 since
2/3 = 1/3 + 1/3 = 1/2 + 1/6 = 1/4 + 1/4 + 1/6 = 1/3 + 1/6 + 1/6
enumerates all of the valid partitions.
Input
The input is a sequence of at most 1000 data sets followed by a terminator.
A data set is a line containing four positive integers p, q, a, and n satisfying p,q <= 800, a <= 12000 and n <= 7. The integers are separated by a space.
The terminator is composed of just one line which contains four zeros separated by a space. It is not a part of the input data but a mark for the end of the input.
Output
The output should be composed of lines each of which contains a single integer. No other characters should appear in the output.
The output integer corresponding to a data set p, q, a, n should be the number of all partitions of p/q into at most n many unit fractions such that the product of the denominators of the unit fractions is less than or equal to a.
Example
Input
2 3 120 3
2 3 300 3
2 3 299 3
2 3 12 3
2 3 12000 7
54 795 12000 7
2 3 300 1
2 1 200 5
2 4 54 2
0 0 0 0
Output
4
7
6
2
42
1
0
9
3
"Correct Solution:
```
from functools import lru_cache
@lru_cache(maxsize=1<<10)
def solve(p,q,a,n):
def _solve(num,dem,d,m,s):
if num==0:
return 1
if d == 0:
return 0
if num * a //m < dem:
return 0
return sum((_solve(num*i-dem, dem*i, d-1, m*i, i) for i in range(s, min(dem*n//num, a//m)+1)),0)
return _solve(p,q,n,1,1)
ans=[]
while True:
p,q,a,n=map(int,input().split())
if p==0:
break
ans.append(solve(p,q,a,n))
print(*ans, sep="\n")
```
| 95,224 |
Provide a correct Python 3 solution for this coding contest problem.
A fraction whose numerator is 1 and whose denominator is a positive integer is called a unit fraction. A representation of a positive rational number p/q as the sum of finitely many unit fractions is called a partition of p/q into unit fractions. For example, 1/2 + 1/6 is a partition of 2/3 into unit fractions. The difference in the order of addition is disregarded. For example, we do not distinguish 1/6 + 1/2 from 1/2 + 1/6.
For given four positive integers p, q, a, and n, count the number of partitions of p/q into unit fractions satisfying the following two conditions.
* The partition is the sum of at most n many unit fractions.
* The product of the denominators of the unit fractions in the partition is less than or equal to a.
For example, if (p,q,a,n) = (2,3,120,3), you should report 4 since
2/3 = 1/3 + 1/3 = 1/2 + 1/6 = 1/4 + 1/4 + 1/6 = 1/3 + 1/6 + 1/6
enumerates all of the valid partitions.
Input
The input is a sequence of at most 1000 data sets followed by a terminator.
A data set is a line containing four positive integers p, q, a, and n satisfying p,q <= 800, a <= 12000 and n <= 7. The integers are separated by a space.
The terminator is composed of just one line which contains four zeros separated by a space. It is not a part of the input data but a mark for the end of the input.
Output
The output should be composed of lines each of which contains a single integer. No other characters should appear in the output.
The output integer corresponding to a data set p, q, a, n should be the number of all partitions of p/q into at most n many unit fractions such that the product of the denominators of the unit fractions is less than or equal to a.
Example
Input
2 3 120 3
2 3 300 3
2 3 299 3
2 3 12 3
2 3 12000 7
54 795 12000 7
2 3 300 1
2 1 200 5
2 4 54 2
0 0 0 0
Output
4
7
6
2
42
1
0
9
3
"Correct Solution:
```
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def main():
rr = []
def f(p, q, a, n):
r = 0
fr = fractions.Fraction(p,q)
q = [(fr, 0, 1)]
if fr.numerator == 1 and fr.denominator <= a:
r += 1
n1 = n-1
for i in range(1, 70):
nq = []
ti = fractions.Fraction(1, i)
i2 = (i+1) ** 2
for t, c, m in q:
mik = m
tt = t
for k in range(1, n-c):
mik *= i
tt -= ti
if tt <= 0 or a < mik * i:
break
if tt.numerator == 1 and tt.denominator >= i and mik * tt.denominator <= a:
r += 1
if c+k < n1 and mik * (i ** max(math.ceil(tt / ti), 2)) < a:
nq.append((tt, c+k, mik))
if m * (i ** max(math.ceil(t / ti), 2)) < a:
nq.append((t,c,m))
if not nq:
break
q = nq
return r
while True:
p, q, a, n = LI()
if p == 0 and q == 0:
break
rr.append(f(p, q, a, n))
return '\n'.join(map(str, rr))
print(main())
```
| 95,225 |
Provide a correct Python 3 solution for this coding contest problem.
A fraction whose numerator is 1 and whose denominator is a positive integer is called a unit fraction. A representation of a positive rational number p/q as the sum of finitely many unit fractions is called a partition of p/q into unit fractions. For example, 1/2 + 1/6 is a partition of 2/3 into unit fractions. The difference in the order of addition is disregarded. For example, we do not distinguish 1/6 + 1/2 from 1/2 + 1/6.
For given four positive integers p, q, a, and n, count the number of partitions of p/q into unit fractions satisfying the following two conditions.
* The partition is the sum of at most n many unit fractions.
* The product of the denominators of the unit fractions in the partition is less than or equal to a.
For example, if (p,q,a,n) = (2,3,120,3), you should report 4 since
2/3 = 1/3 + 1/3 = 1/2 + 1/6 = 1/4 + 1/4 + 1/6 = 1/3 + 1/6 + 1/6
enumerates all of the valid partitions.
Input
The input is a sequence of at most 1000 data sets followed by a terminator.
A data set is a line containing four positive integers p, q, a, and n satisfying p,q <= 800, a <= 12000 and n <= 7. The integers are separated by a space.
The terminator is composed of just one line which contains four zeros separated by a space. It is not a part of the input data but a mark for the end of the input.
Output
The output should be composed of lines each of which contains a single integer. No other characters should appear in the output.
The output integer corresponding to a data set p, q, a, n should be the number of all partitions of p/q into at most n many unit fractions such that the product of the denominators of the unit fractions is less than or equal to a.
Example
Input
2 3 120 3
2 3 300 3
2 3 299 3
2 3 12 3
2 3 12000 7
54 795 12000 7
2 3 300 1
2 1 200 5
2 4 54 2
0 0 0 0
Output
4
7
6
2
42
1
0
9
3
"Correct Solution:
```
from fractions import gcd
def solve(p, q, a, n, l=1):
ans = 1 if p==1 and q<=a and q>=l else 0
denom = max(l, q//p)
p_denom = denom*p
while n*q >= p_denom and denom <= a: #n/denom >= p/q:
p_, q_ = p_denom-q, q*denom
if p_ <= 0:
denom += 1
p_denom += p
continue
gcd_ = gcd(p_, q_)
p_ //= gcd_
q_ //= gcd_
if n==2 and p_==1 and q_*denom<=a and q_>=denom:
ans += 1
else:
ans += solve(p_, q_, a//denom, n-1, denom)
denom += 1
p_denom += p
#print(p, q, a, n, l, ans)
return ans
while True:
p, q, a, n = map(int, input().split())
if p==q==a==n==0:
break
gcd_ = gcd(p, q)
p //= gcd_
q //= gcd_
if n==1:
print(1 if p==1 and q<=a else 0)
else:
print(solve(p, q, a, n))
```
| 95,226 |
Provide a correct Python 3 solution for this coding contest problem.
A fraction whose numerator is 1 and whose denominator is a positive integer is called a unit fraction. A representation of a positive rational number p/q as the sum of finitely many unit fractions is called a partition of p/q into unit fractions. For example, 1/2 + 1/6 is a partition of 2/3 into unit fractions. The difference in the order of addition is disregarded. For example, we do not distinguish 1/6 + 1/2 from 1/2 + 1/6.
For given four positive integers p, q, a, and n, count the number of partitions of p/q into unit fractions satisfying the following two conditions.
* The partition is the sum of at most n many unit fractions.
* The product of the denominators of the unit fractions in the partition is less than or equal to a.
For example, if (p,q,a,n) = (2,3,120,3), you should report 4 since
2/3 = 1/3 + 1/3 = 1/2 + 1/6 = 1/4 + 1/4 + 1/6 = 1/3 + 1/6 + 1/6
enumerates all of the valid partitions.
Input
The input is a sequence of at most 1000 data sets followed by a terminator.
A data set is a line containing four positive integers p, q, a, and n satisfying p,q <= 800, a <= 12000 and n <= 7. The integers are separated by a space.
The terminator is composed of just one line which contains four zeros separated by a space. It is not a part of the input data but a mark for the end of the input.
Output
The output should be composed of lines each of which contains a single integer. No other characters should appear in the output.
The output integer corresponding to a data set p, q, a, n should be the number of all partitions of p/q into at most n many unit fractions such that the product of the denominators of the unit fractions is less than or equal to a.
Example
Input
2 3 120 3
2 3 300 3
2 3 299 3
2 3 12 3
2 3 12000 7
54 795 12000 7
2 3 300 1
2 1 200 5
2 4 54 2
0 0 0 0
Output
4
7
6
2
42
1
0
9
3
"Correct Solution:
```
from functools import lru_cache
@lru_cache(maxsize=1<<10)
def solve(p, q, a, n):
def _solve(num, dem, d, m, s):
if num == 0:
return 1
if d == 0:
return 0
if num * a // m < dem:
return 0
return sum((_solve(num*i-dem, dem*i, d-1, m*i, i)
for i in range(s, min(dem*n//num, a//m)+1)), 0)
return _solve(p, q, n, 1, 1)
if __name__ == "__main__":
ans = []
while True:
p, q, a, n = [int(i) for i in input().split()]
if p == 0:
break
ans.append(solve(p, q, a, n))
print(*ans, sep="\n")
```
| 95,227 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A fraction whose numerator is 1 and whose denominator is a positive integer is called a unit fraction. A representation of a positive rational number p/q as the sum of finitely many unit fractions is called a partition of p/q into unit fractions. For example, 1/2 + 1/6 is a partition of 2/3 into unit fractions. The difference in the order of addition is disregarded. For example, we do not distinguish 1/6 + 1/2 from 1/2 + 1/6.
For given four positive integers p, q, a, and n, count the number of partitions of p/q into unit fractions satisfying the following two conditions.
* The partition is the sum of at most n many unit fractions.
* The product of the denominators of the unit fractions in the partition is less than or equal to a.
For example, if (p,q,a,n) = (2,3,120,3), you should report 4 since
2/3 = 1/3 + 1/3 = 1/2 + 1/6 = 1/4 + 1/4 + 1/6 = 1/3 + 1/6 + 1/6
enumerates all of the valid partitions.
Input
The input is a sequence of at most 1000 data sets followed by a terminator.
A data set is a line containing four positive integers p, q, a, and n satisfying p,q <= 800, a <= 12000 and n <= 7. The integers are separated by a space.
The terminator is composed of just one line which contains four zeros separated by a space. It is not a part of the input data but a mark for the end of the input.
Output
The output should be composed of lines each of which contains a single integer. No other characters should appear in the output.
The output integer corresponding to a data set p, q, a, n should be the number of all partitions of p/q into at most n many unit fractions such that the product of the denominators of the unit fractions is less than or equal to a.
Example
Input
2 3 120 3
2 3 300 3
2 3 299 3
2 3 12 3
2 3 12000 7
54 795 12000 7
2 3 300 1
2 1 200 5
2 4 54 2
0 0 0 0
Output
4
7
6
2
42
1
0
9
3
Submitted Solution:
```
from fractions import Fraction
def frac(n):
return(Fraction(1,n))
def part(s,a,n,m):
if s == 0:
return(1)
k = int(1/s)
if n == 1:
if frac(k) == s and k <= a:
return(1)
else:
return(0)
else:
ans = 0
for i in range(max(k,m),min(a,int(n/s))+1):
t = s-frac(i)
if t == 0:
ans += 1
elif t>0:
ans += part(s-frac(i), a//i, n-1, i)
return(ans)
while(True):
tmp = list(map(int, input().split()))
p,q,a,n = tmp[0],tmp[1],tmp[2],tmp[3]
if p == 0:
quit()
s = Fraction(p,q)
print(part(s,a,n,1))
```
No
| 95,228 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A fraction whose numerator is 1 and whose denominator is a positive integer is called a unit fraction. A representation of a positive rational number p/q as the sum of finitely many unit fractions is called a partition of p/q into unit fractions. For example, 1/2 + 1/6 is a partition of 2/3 into unit fractions. The difference in the order of addition is disregarded. For example, we do not distinguish 1/6 + 1/2 from 1/2 + 1/6.
For given four positive integers p, q, a, and n, count the number of partitions of p/q into unit fractions satisfying the following two conditions.
* The partition is the sum of at most n many unit fractions.
* The product of the denominators of the unit fractions in the partition is less than or equal to a.
For example, if (p,q,a,n) = (2,3,120,3), you should report 4 since
2/3 = 1/3 + 1/3 = 1/2 + 1/6 = 1/4 + 1/4 + 1/6 = 1/3 + 1/6 + 1/6
enumerates all of the valid partitions.
Input
The input is a sequence of at most 1000 data sets followed by a terminator.
A data set is a line containing four positive integers p, q, a, and n satisfying p,q <= 800, a <= 12000 and n <= 7. The integers are separated by a space.
The terminator is composed of just one line which contains four zeros separated by a space. It is not a part of the input data but a mark for the end of the input.
Output
The output should be composed of lines each of which contains a single integer. No other characters should appear in the output.
The output integer corresponding to a data set p, q, a, n should be the number of all partitions of p/q into at most n many unit fractions such that the product of the denominators of the unit fractions is less than or equal to a.
Example
Input
2 3 120 3
2 3 300 3
2 3 299 3
2 3 12 3
2 3 12000 7
54 795 12000 7
2 3 300 1
2 1 200 5
2 4 54 2
0 0 0 0
Output
4
7
6
2
42
1
0
9
3
Submitted Solution:
```
from fractions import Fraction
def frac(n):
return(Fraction(1,n))
def part(s,a,n,m):
if s == 0:
return(1)
k = int(1/s)
if n == 1:
if frac(k) == s and k <= a:
return(1)
else:
return(0)
else:
ans = 0
for i in range(max(k,m),min(a,int(n/s))+1):
ans += part(s-frac(i), a//i, n-1, i)
return(ans)
while(True):
tmp = list(map(int, input().split()))
p,q,a,n = tmp[0],tmp[1],tmp[2],tmp[3]
if p == 0:
quit()
s = Fraction(p,q)
print(part(s,a,n,1))
```
No
| 95,229 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A fraction whose numerator is 1 and whose denominator is a positive integer is called a unit fraction. A representation of a positive rational number p/q as the sum of finitely many unit fractions is called a partition of p/q into unit fractions. For example, 1/2 + 1/6 is a partition of 2/3 into unit fractions. The difference in the order of addition is disregarded. For example, we do not distinguish 1/6 + 1/2 from 1/2 + 1/6.
For given four positive integers p, q, a, and n, count the number of partitions of p/q into unit fractions satisfying the following two conditions.
* The partition is the sum of at most n many unit fractions.
* The product of the denominators of the unit fractions in the partition is less than or equal to a.
For example, if (p,q,a,n) = (2,3,120,3), you should report 4 since
2/3 = 1/3 + 1/3 = 1/2 + 1/6 = 1/4 + 1/4 + 1/6 = 1/3 + 1/6 + 1/6
enumerates all of the valid partitions.
Input
The input is a sequence of at most 1000 data sets followed by a terminator.
A data set is a line containing four positive integers p, q, a, and n satisfying p,q <= 800, a <= 12000 and n <= 7. The integers are separated by a space.
The terminator is composed of just one line which contains four zeros separated by a space. It is not a part of the input data but a mark for the end of the input.
Output
The output should be composed of lines each of which contains a single integer. No other characters should appear in the output.
The output integer corresponding to a data set p, q, a, n should be the number of all partitions of p/q into at most n many unit fractions such that the product of the denominators of the unit fractions is less than or equal to a.
Example
Input
2 3 120 3
2 3 300 3
2 3 299 3
2 3 12 3
2 3 12000 7
54 795 12000 7
2 3 300 1
2 1 200 5
2 4 54 2
0 0 0 0
Output
4
7
6
2
42
1
0
9
3
Submitted Solution:
```
from fractions import gcd
def solve(p, q, a, n, l=1):
#if n==1:
# #print(p, q, a, n, l, 1 if p==1 and q<=a and q>=l else 0)
# return 1 if p==1 and q<=a and q>=l else 0
ans = 1 if p==1 and q<=a and q>=l else 0
#denom = l if p==0 else max(l, int(q/p))
for denom in range(max(l, int(q/p)), a+1): #n/denom >= p/q:
if n*q < denom*p: break
p_, q_ = p*denom-q, q*denom
if p_ <= 0:
denom += 1
continue
gcd_ = gcd(p_, q_)
p_ //= gcd_
q_ //= gcd_
if n==2 and p_==1 and q_*denom<=a and q_>=denom:
ans += 1
else:
ans += solve(p_, q_, a//denom, n-1, denom)
denom += 1
#print(p, q, a, n, l, ans)
return ans
while True:
p, q, a, n = map(int, input().split())
if p==q==a==n==0:
break
gcd_ = gcd(p, q)
p //= gcd_
q //= gcd_
if n==1:
print(1 if p==1 and q<=a else 0)
else:
print(solve(p, q, a, n))
```
No
| 95,230 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A fraction whose numerator is 1 and whose denominator is a positive integer is called a unit fraction. A representation of a positive rational number p/q as the sum of finitely many unit fractions is called a partition of p/q into unit fractions. For example, 1/2 + 1/6 is a partition of 2/3 into unit fractions. The difference in the order of addition is disregarded. For example, we do not distinguish 1/6 + 1/2 from 1/2 + 1/6.
For given four positive integers p, q, a, and n, count the number of partitions of p/q into unit fractions satisfying the following two conditions.
* The partition is the sum of at most n many unit fractions.
* The product of the denominators of the unit fractions in the partition is less than or equal to a.
For example, if (p,q,a,n) = (2,3,120,3), you should report 4 since
2/3 = 1/3 + 1/3 = 1/2 + 1/6 = 1/4 + 1/4 + 1/6 = 1/3 + 1/6 + 1/6
enumerates all of the valid partitions.
Input
The input is a sequence of at most 1000 data sets followed by a terminator.
A data set is a line containing four positive integers p, q, a, and n satisfying p,q <= 800, a <= 12000 and n <= 7. The integers are separated by a space.
The terminator is composed of just one line which contains four zeros separated by a space. It is not a part of the input data but a mark for the end of the input.
Output
The output should be composed of lines each of which contains a single integer. No other characters should appear in the output.
The output integer corresponding to a data set p, q, a, n should be the number of all partitions of p/q into at most n many unit fractions such that the product of the denominators of the unit fractions is less than or equal to a.
Example
Input
2 3 120 3
2 3 300 3
2 3 299 3
2 3 12 3
2 3 12000 7
54 795 12000 7
2 3 300 1
2 1 200 5
2 4 54 2
0 0 0 0
Output
4
7
6
2
42
1
0
9
3
Submitted Solution:
```
from fractions import gcd
def solve(p, q, a, n, l=1):
#if n==1:
# #print(p, q, a, n, l, 1 if p==1 and q<=a and q>=l else 0)
# return 1 if p==1 and q<=a and q>=l else 0
ans = 1 if p==1 and q<=a and q>=l else 0
denom = l if p==0 else max(l, int(q/p))
while n*q >= denom*p and denom <= a: #n/denom >= p/q:
p_, q_ = p*denom-q, q*denom
if p_ <= 0:
denom += 1
continue
gcd_ = gcd(p_, q_)
p_ //= gcd_
q_ //= gcd_
if n==2 and p_==1 and q_*denom<=a and q_>=denom:
ans += 1
else:
ans += solve(p_, q_, a//denom, n-1, denom)
denom += 1
#print(p, q, a, n, l, ans)
return ans
while True:
p, q, a, n = map(int, input().split())
if p==q==a==n==0:
break
gcd_ = gcd(p, q)
p //= gcd_
q //= gcd_
if n==1:
print(1 if p==1 and q<=a else 0)
else:
print(solve(p, q, a, n))
```
No
| 95,231 |
Provide a correct Python 3 solution for this coding contest problem.
Reordering the Documents
Susan is good at arranging her dining table for convenience, but not her office desk.
Susan has just finished the paperwork on a set of documents, which are still piled on her desk. They have serial numbers and were stacked in order when her boss brought them in. The ordering, however, is not perfect now, as she has been too lazy to put the documents slid out of the pile back to their proper positions. Hearing that she has finished, the boss wants her to return the documents immediately in the document box he is sending her. The documents should be stowed in the box, of course, in the order of their serial numbers.
The desk has room just enough for two more document piles where Susan plans to make two temporary piles. All the documents in the current pile are to be moved one by one from the top to either of the two temporary piles. As making these piles too tall in haste would make them tumble, not too many documents should be placed on them. After moving all the documents to the temporary piles and receiving the document box, documents in the two piles will be moved from their tops, one by one, into the box. Documents should be in reverse order of their serial numbers in the two piles to allow moving them to the box in order.
For example, assume that the pile has six documents #1, #3, #4, #2, #6, and #5, in this order from the top, and that the temporary piles can have no more than three documents. Then, she can form two temporary piles, one with documents #6, #4, and #3, from the top, and the other with #5, #2, and #1 (Figure E.1). Both of the temporary piles are reversely ordered. Then, comparing the serial numbers of documents on top of the two temporary piles, one with the larger number (#6, in this case) is to be removed and stowed into the document box first. Repeating this, all the documents will be perfectly ordered in the document box.
<image>
Figure E.1. Making two temporary piles
Susan is wondering whether the plan is actually feasible with the documents in the current pile and, if so, how many different ways of stacking them to two temporary piles would do. You are asked to help Susan by writing a program to compute the number of different ways, which should be zero if the plan is not feasible.
As each of the documents in the pile can be moved to either of the two temporary piles, for $n$ documents, there are $2^n$ different choice combinations in total, but some of them may disturb the reverse order of the temporary piles and are thus inappropriate.
The example described above corresponds to the first case of the sample input. In this case, the last two documents, #5 and #6, can be swapped their destinations. Also, exchanging the roles of two temporary piles totally will be OK. As any other move sequences would make one of the piles higher than three and/or make them out of order, the total number of different ways of stacking documents to temporary piles in this example is $2 \times 2 = 4$.
Input
The input consists of a single test case of the following format.
$n$ $m$
$s_1$ ... $s_n$
Here, $n$ is the number of documents in the pile ($1 \leq n \leq 5000$), and $m$ is the number of documents that can be stacked in one temporary pile without committing risks of making it tumble down ($n/2 \leq m \leq n$). Numbers $s_1$ through $s_n$ are the serial numbers of the documents in the document pile, from its top to its bottom. It is guaranteed that all the numbers $1$ through $n$ appear exactly once.
Output
Output a single integer in a line which is the number of ways to form two temporary piles suited for the objective. When no choice will do, the number of ways is $0$, of course.
If the number of possible ways is greater than or equal to $10^9 + 7$, output the number of ways modulo $10^9 + 7$.
Sample Input 1
6 3
1 3 4 2 6 5
Sample Output 1
4
Sample Input 2
6 6
1 3 4 2 6 5
Sample Output 2
8
Sample Input 3
4 4
4 3 1 2
Sample Output 3
0
Example
Input
6 3
1 3 4 2 6 5
Output
4
"Correct Solution:
```
def main():
mod = 10 ** 9 + 7
n, m = map(int, input().split())
a = [int(x) for x in input().split()]
if not m:
print(0)
return
mx = [0] * (n + 1)
mn = [mod] * (n + 1)
for i in range(n):
if mx[i] > a[i]:
mx[i + 1] = mx[i]
else:
mx[i + 1] = a[i]
for i in range(n - 1, -1, -1):
if mn[i + 1] < a[i]:
mn[i] = mn[i + 1]
else:
mn[i] = a[i]
dp = [0] * (n + 1)
dp[1] = 2
for i in range(1, n):
ndp = [0] * (n + 1)
check0 = mx[i + 1] == a[i]
check1 = mn[i + 1] >= mx[i]
check2 = mn[i] == a[i]
if check0:
if check1:
for j in range(i + 1):
ndp[j + 1] += dp[j]
ndp[i - j + 1] += dp[j]
else:
for j in range(i + 1):
ndp[j + 1] += dp[j]
else:
if check2:
for j in range(i + 1):
ndp[j] += dp[j]
dp = [x % mod for x in ndp]
ans = 0
for i in range(n - m, m + 1):
ans += dp[i]
ans %= mod
print(ans)
if __name__ == "__main__":
main()
```
| 95,232 |
Provide a correct Python 3 solution for this coding contest problem.
Expression Mining
Consider an arithmetic expression built by combining single-digit positive integers with addition symbols `+`, multiplication symbols `*`, and parentheses `(` `)`, defined by the following grammar rules with the start symbol `E`.
E ::= T | E '+' T
T ::= F | T '*' F
F ::= '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' | '(' E ')'
When such an arithmetic expression is viewed as a string, its substring, that is, a contiguous sequence of characters within the string, may again form an arithmetic expression. Given an integer n and a string s representing an arithmetic expression, let us count the number of its substrings that can be read as arithmetic expressions with values computed equal to n.
Input
The input consists of multiple datasets, each in the following format.
> n
> s
>
A dataset consists of two lines. In the first line, the target value n is given. n is an integer satisfying 1 ≤ n ≤ 109. The string s given in the second line is an arithmetic expression conforming to the grammar defined above. The length of s does not exceed 2×106. The nesting depth of the parentheses in the string is at most 1000.
The end of the input is indicated by a line containing a single zero. The sum of the lengths of s in all the datasets does not exceed 5×106.
Output
For each dataset, output in one line the number of substrings of s that conform to the above grammar and have the value n. The same sequence of characters appearing at different positions should be counted separately.
Sample Input
3
(1+2)*3+3
2
1*1*1+1*1*1
587
1*(2*3*4)+5+((6+7*8))*(9)
0
Output for the Sample Input
4
9
2
Example
Input
3
(1+2)*3+3
2
1*1*1+1*1*1
587
1*(2*3*4)+5+((6+7*8))*(9)
0
Output
4
9
2
"Correct Solution:
```
import sys
readline = sys.stdin.readline
write = sys.stdout.write
sys.setrecursionlimit(10**5)
def solve():
N = int(readline())
if N == 0:
return False
S = readline().strip() + "$"
L = len(S)
pt = [0]*L
st = []
for i in range(L):
if S[i] == '(':
st.append(i)
elif S[i] == ')':
k = st.pop()
pt[i] = k
pt[k] = i
ans = 0
def parse(cur):
nonlocal ans
ps = []
ls = []
su = 0
while 1:
ms = []
while 1:
if S[cur] == '(':
v = parse(cur+1)
cur = pt[cur]+1
else:
v = int(S[cur])
cur += 1
ms.append(v)
if S[cur] != '*':
break
cur += 1
l = len(ms)
ms_a = [1]*(l+1)
for i in range(l):
ms_a[i+1] = ms_a[i] * ms[i]
ps.append(ms_a)
ls.append(l)
su += ms_a[-1]
if S[cur] != '+':
break
cur += 1
p1 = c1 = 0; s1 = 0
q1 = d1 = 0; t1 = 0; u1 = 0
q2 = d2 = 0; t2 = 0; u2 = 0
s = 0
while p1 < len(ls):
k1 = ps[p1][c1+1]
if s1 + k1 >= N:
break
if c1 + 1 < ls[p1]:
c1 += 1
else:
s1 += ps[p1][-1]
p1 += 1; c1 = 0
while p1 < len(ls):
k1 = ps[p1][c1+1]
while (q1, d1) <= (p1, c1):
k2 = ps[q1][d1]
if p1 == q1:
v = (s1 - t1) + (k1 // k2)
else:
kk = ps[q1][-1]
v = (s1 - t1) + (k1 + kk // k2 - kk)
if v >= N:
if d1 + 1 < ls[q1]:
d1 += 1
else:
t1 += ps[q1][-1]
q1 += 1; d1 = 0
u1 += 1
else:
break
while (q2, d2) <= (p1, c1):
k3 = ps[q2][d2]
if p1 == q2:
v = (s1 - t2) + (k1 // k3)
else:
kk = ps[q2][-1]
v = (s1 - t2) + (k1 + kk // k3 - kk)
if v > N:
if d2 + 1 < ls[q2]:
d2 += 1
else:
t2 += ps[q2][-1]
q2 += 1; d2 = 0
u2 += 1
else:
break
ans += u1 - u2
if c1 + 1 < ls[p1]:
c1 += 1
else:
s1 += ps[p1][-1]
p1 += 1; c1 = 0
return su
parse(0)
write("%d\n" % ans)
return True
while solve():
...
```
| 95,233 |
Provide a correct Python 3 solution for this coding contest problem.
Training is indispensable for achieving good results at ICPC. Rabbit wants to win at ICPC, so he decided to practice today as well.
Today's training is to increase creativity by drawing pictures. Let's draw a pattern well using a square stamp.
I want to use stamps of various sizes to complete the picture of the red, green, and blue streets specified on the 4 x 4 squared paper. The stamp is rectangular and is used to fit the squares. The height and width of the stamp cannot be swapped.
The paper is initially uncolored. When you stamp on paper, the stamped part changes to the color of the stamp, and the color hidden underneath becomes completely invisible. Since the color of the stamp is determined by the ink to be applied, it is possible to choose the color of any stamp. The stamp can be stamped with a part protruding from the paper, and the protruding part is ignored.
It is possible to use one stamp multiple times. You may use the same stamp for different colors. Stamping is a rather nerve-wracking task, so I want to reduce the number of stamps as much as possible.
Input
N
H1 W1
...
HN WN
C1,1C1,2C1,3C1,4
C2,1C2,2C2,3C2,4
C3,1C3,2C3,3C3,4
C4,1C4,2C4,3C4,4
N is the number of stamps, and Hi and Wi (1 ≤ i ≤ N) are integers representing the vertical and horizontal lengths of the i-th stamp, respectively. Ci, j (1 ≤ i ≤ 4, 1 ≤ j ≤ 4) is a character that represents the color of the picture specified for the cells in the i-th row from the top and the j-th column from the left. Red is represented by `R`, green is represented by` G`, and blue is represented by `B`.
Satisfy 1 ≤ N ≤ 16, 1 ≤ Hi ≤ 4, 1 ≤ Wi ≤ 4. The same set as (Hi, Wi) does not appear multiple times.
Output
Print the minimum number of stamps that must be stamped to complete the picture on a single line.
Examples
Input
2
4 4
1 1
RRRR
RRGR
RBRR
RRRR
Output
3
Input
1
2 3
RRGG
BRGG
BRRR
BRRR
Output
5
"Correct Solution:
```
def solve():
from sys import stdin
from itertools import combinations
file_input = stdin
N = int(file_input.readline())
hw = [tuple(map(int, file_input.readline().split())) for i in range(N)]
goal = (line.rstrip() for line in file_input)
goal = ''.join(goal)
R = 0
G = 0
B = 0
b = 1
for c in goal[:]:
if c == 'R':
R += b
elif c == 'G':
G += b
else:
B += b
b <<= 1
c_m = (R, G, B) # color mask
g_m = (1 << 16) - 1 # goal mask
stamps = []
for r1, r2 in combinations(range(5), 2):
rw = r2 - r1
for c1, c2 in combinations(range(5), 2):
cw = c2 - c1
for h, w in hw:
if (rw == h and cw == w) or \
((r1 == 0 or r2 == 4) and rw < h and cw == w) or \
((c1 == 0 or c2 == 4) and cw < w and rw == h) or \
((r1 == 0 or r2 == 4) and (c1 == 0 or c2 == 4) and \
rw < h and cw < w):
m = 1
for i in range(cw - 1):
m <<= 1
m += 1
m <<= c1
r_m = m
for i in range(rw - 1):
m <<= 4
m += r_m
m <<= (r1 * 4)
for c in c_m:
s = c & m
if s:
stamps.append((m ^ g_m, s))
break
picture = [0]
generated_picture = [False] * (2 ** 16)
generated_picture[0] = True
step = 0
while True:
t_picture = picture[:]
picture = []
step += 1
for p in t_picture:
for m, s in stamps:
n_p = p & m | s
if generated_picture[n_p]:
continue
if n_p == g_m:
return step
generated_picture[n_p] = True
picture.append(n_p)
print(solve())
```
| 95,234 |
Provide a correct Python 3 solution for this coding contest problem.
Training is indispensable for achieving good results at ICPC. Rabbit wants to win at ICPC, so he decided to practice today as well.
Today's training is to increase creativity by drawing pictures. Let's draw a pattern well using a square stamp.
I want to use stamps of various sizes to complete the picture of the red, green, and blue streets specified on the 4 x 4 squared paper. The stamp is rectangular and is used to fit the squares. The height and width of the stamp cannot be swapped.
The paper is initially uncolored. When you stamp on paper, the stamped part changes to the color of the stamp, and the color hidden underneath becomes completely invisible. Since the color of the stamp is determined by the ink to be applied, it is possible to choose the color of any stamp. The stamp can be stamped with a part protruding from the paper, and the protruding part is ignored.
It is possible to use one stamp multiple times. You may use the same stamp for different colors. Stamping is a rather nerve-wracking task, so I want to reduce the number of stamps as much as possible.
Input
N
H1 W1
...
HN WN
C1,1C1,2C1,3C1,4
C2,1C2,2C2,3C2,4
C3,1C3,2C3,3C3,4
C4,1C4,2C4,3C4,4
N is the number of stamps, and Hi and Wi (1 ≤ i ≤ N) are integers representing the vertical and horizontal lengths of the i-th stamp, respectively. Ci, j (1 ≤ i ≤ 4, 1 ≤ j ≤ 4) is a character that represents the color of the picture specified for the cells in the i-th row from the top and the j-th column from the left. Red is represented by `R`, green is represented by` G`, and blue is represented by `B`.
Satisfy 1 ≤ N ≤ 16, 1 ≤ Hi ≤ 4, 1 ≤ Wi ≤ 4. The same set as (Hi, Wi) does not appear multiple times.
Output
Print the minimum number of stamps that must be stamped to complete the picture on a single line.
Examples
Input
2
4 4
1 1
RRRR
RRGR
RBRR
RRRR
Output
3
Input
1
2 3
RRGG
BRGG
BRRR
BRRR
Output
5
"Correct Solution:
```
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**13
mod = 10**9+7
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def main():
rr = []
def f(n):
a = [LI() for _ in range(n)]
b = []
for _ in range(4):
b += [c for c in S()]
s = set()
ms = 2**16 - 1
ii = [2**i for i in range(16)]
for h, w in a:
for i in range(-h+1, 4):
for j in range(-w+1, 4):
mask = ms
for k in range(max(0, i), min(4, i+h)):
for l in range(max(0, j), min(4, j+w)):
mask -= ii[k*4+l]
s.add(mask)
ta = []
for mask in s:
for c in 'RGB':
t = 0
for i in range(16):
if ii[i] & mask:
continue
if b[i] == c:
t += ii[i]
if t > 0:
ta.append((mask, t))
v = collections.defaultdict(bool)
q = set([0])
r = 0
while q:
r += 1
nq = set()
for c in q:
v[c] = True
for c in q:
for mask, t in ta:
n = (c & mask) + t
if v[n]:
continue
if n == ms:
return r
nq.add(n)
q = nq
return -1
while 1:
n = I()
if n == 0:
break
rr.append(f(n))
break
return '\n'.join(map(str, rr))
print(main())
```
| 95,235 |
Provide a correct Python 3 solution for this coding contest problem.
In the International City of Pipe Construction, it is planned to repair the water pipe at a certain point in the water pipe network. The network consists of water pipe segments, stop valves and source point. A water pipe is represented by a segment on a 2D-plane and intersected pair of water pipe segments are connected at the intersection point. A stop valve, which prevents from water flowing into the repairing point while repairing, is represented by a point on some water pipe segment. In the network, just one source point exists and water is supplied to the network from this point.
Of course, while repairing, we have to stop water supply in some areas, but, in order to reduce the risk of riots, the length of water pipes stopping water supply must be minimized. What you have to do is to write a program to minimize the length of water pipes needed to stop water supply when the coordinates of end points of water pipe segments, stop valves, source point and repairing point are given.
Input
A data set has the following format:
> N M
> xs1 ys1 xd1 yd1
> ...
> xsN ysN xdN ydN
> xv1 yv1
> ...
> xvM yvM
> xb yb
> xc yc
>
The first line of the input contains two integers, N (1 ≤ N ≤ 300) and M (0 ≤ M ≤ 1,000) that indicate the number of water pipe segments and stop valves. The following N lines describe the end points of water pipe segments. The i-th line contains four integers, xsi, ysi, xdi and ydi that indicate the pair of coordinates of end points of i-th water pipe segment. The following M lines describe the points of stop valves. The i-th line contains two integers, xvi and yvi that indicate the coordinate of end points of i-th stop valve. The following line contains two integers, xb and yb that indicate the coordinate of the source point. The last line contains two integers, xc and yc that indicate the coordinate of the repairing point.
You may assume that any absolute values of coordinate integers are less than 1,000 (inclusive.) You may also assume each of the stop valves, the source point and the repairing point is always on one of water pipe segments and that that each pair among the stop valves, the source point and the repairing point are different. And, there is not more than one intersection between each pair of water pipe segments. Finally, the water pipe network is connected, that is, all the water pipes are received water supply initially.
Output
Print the minimal length of water pipes needed to stop water supply in a line. The absolute or relative error should be less than or 10-6. When you cannot stop water supply to the repairing point even though you close all stop valves, print "`-1`" in a line.
Examples
Input
1 2
0 0 10 0
1 0
9 0
0 0
5 0
Output
9.0
Input
5 3
0 4 2 4
0 2 2 2
0 0 2 0
0 0 0 4
2 0 2 4
0 2
1 0
2 2
1 4
2 1
Output
3.0
Input
2 1
0 0 0 4
0 2 2 2
1 2
0 1
0 3
Output
-1
"Correct Solution:
```
from collections import deque
import sys
readline = sys.stdin.readline
write = sys.stdout.write
def dot3(O, A, B):
ox, oy = O; ax, ay = A; bx, by = B
return (ax - ox) * (bx - ox) + (ay - oy) * (by - oy)
def cross3(O, A, B):
ox, oy = O; ax, ay = A; bx, by = B
return (ax - ox) * (by - oy) - (bx - ox) * (ay - oy)
def dist2(A, B):
ax, ay = A; bx, by = B
return (ax - bx) ** 2 + (ay - by) ** 2
def is_intersection(L1, L2):
P0 = L1[:2]; P1 = L1[2:]
Q0 = L2[:2]; Q1 = L2[2:]
C0 = cross3(P0, P1, Q0)
C1 = cross3(P0, P1, Q1)
D0 = cross3(Q0, Q1, P0)
D1 = cross3(Q0, Q1, P1)
if C0 == C1 == 0:
return False
return C0 * C1 <= 0 and D0 * D1 <= 0
def cross_point(L1, L2):
x0, y0, x1, y1 = L1
x2, y2, x3, y3 = L2
dx0 = x1 - x0
dy0 = y1 - y0
dx1 = x3 - x2
dy1 = y3 - y2
s = (y0-y2)*dx1 - (x0-x2)*dy1
sm = dx0*dy1 - dy0*dx1
if s < 0:
s = -s
sm = -sm
if s == 0:
x = x0; y = y0
elif s == sm:
x = x1; y = y1
else:
x = x0 + s*dx0/sm; y = y0 + s*dy0/sm
return x, y
def solve():
N, M = map(int, readline().split())
ps = set()
mp = {}
LS = []
for i in range(N):
x1, y1, x2, y2 = map(int, readline().split())
mp[x1, y1] = 0
mp[x2, y2] = 0
LS.append((x1, y1, x2, y2))
for i in range(N):
L1 = LS[i]
for j in range(i+1, N):
L2 = LS[j]
if is_intersection(L1, L2):
x, y = cross_point(L1, L2)
mp[x, y] = 0
for i in range(M):
x, y = map(int, readline().split())
mp[x, y] = 1
xb, yb = map(int, readline().split())
mp[xb, yb] = 2
xc, yc = map(int, readline().split())
mp[xc, yc] = 2
*ps1, = mp.keys()
ps1.sort(key = lambda x: (x[0], x[1]))
mv = {e: i for i, e in enumerate(ps1)}
*ps2, = mp.keys()
ps2.sort(key = lambda x: (x[1], x[0]))
ES = []
ms = list(map(mv.__getitem__, ps2))
ks = list(map(mp.__getitem__, ps1))
K = len(ps1)
G = [[] for i in range(K)]
for x1, y1, x2, y2 in LS:
vs = []
if x1 != x2:
if not x1 <= x2:
x1, y1, x2, y2 = x2, y2, x1, y1
for k, (x, y) in enumerate(ps1):
if x1 <= x <= x2 and abs((x - x1)*(y2 - y1) - (y - y1)*(x2 - x1)) < 1e-6:
vs.append(k)
else:
if not y1 <= y2:
y1, y2 = y2, y1
for k, (x, y) in zip(ms, ps2):
if y1 <= y <= y2 and abs((x - x1)*(y2 - y1) - (y - y1)*(x2 - x1)) < 1e-6:
vs.append(k)
for i in range(len(vs)-1):
k1 = vs[i]; k2 = vs[i+1]
G[k1].append(k2)
G[k2].append(k1)
ES.append((k1, k2) if k1 <= k2 else (k2, k1))
s = mv[xc, yc]; t = mv[xb, yb]
que = deque([s])
used = [0]*K
used[s] = 1
e_used = set()
while que:
v = que.popleft()
for w in G[v]:
if w == t:
write("-1\n")
return
e_used.add((v, w) if v <= w else (w, v))
if not used[w] and ks[w] != 1:
que.append(w)
used[w] = 1
que.append(t)
e_used1 = set()
used = [0]*K
used[t] = 1
while que:
v = que.popleft()
for w in G[v]:
e = (v, w) if v <= w else (w, v)
if e in e_used:
continue
e_used1.add(e)
if not used[w]:
que.append(w)
used[w] = 1
ans = 0
for k1, k2 in ES:
if (k1, k2) in e_used1:
continue
x1, y1 = ps1[k1]; x2, y2 = ps1[k2]
ans += ((x1 - x2)**2 + (y1 - y2)**2)**.5
write("%.16f\n" % ans)
solve()
```
| 95,236 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Problem statement
Here are $ N $ sheets of paper. You want to scan all paper by using $ 3 $ scanners in parallel. Each piece of paper has a fixed scanning time, and the time it takes to scan the $ i $ th paper is $ T_i $. You can scan the paper in any order, but you cannot scan multiple papers at the same time with a $ 1 $ scanner.
Minimize the time it takes to finish scanning all paper and run out of scanners.
Constraint
$ 1 \ leq N \ leq 50 $
$ 1 \ leq T_i \ leq 50 $
All inputs are integers
sample
Sample input 1
Four
1
1
1
1
Sample output 1
2
<image>
Sample input 2
9
15
20
27
Four
Ten
7
34
30
36
Sample output 2
61
<image>
Sample input 3
6
20
18
46
16
9
48
Sample output 3
55
<image>
input
$ N $
$ T_1 $
$ T_2 $
$ T_3 $
$ \ vdots $
$ T_N $
output
Print the answer on the $ 1 $ line.
Example
Input
4
1
1
1
1
Output
2
Submitted Solution:
```
N = int(input())
ts = [int(input()) for i in range(N)]
ma = sum(ts) // 3 + 50
s = [[[0 for i in range(ma)] for j in range(ma)] for k in range(N + 1)]
for i in range(N):
for j in range(ma):
for k in range(j, ma):
p = [s[i][j][k] + ts[i]]
if(j >= ts[i]):
p.append(s[i][j - ts[i]][k])
if(k >= ts[i]):
p.append(s[i][j][k - ts[i]])
s[i + 1][j][k] = s[i + 1][k][j] = min(p)
i = 0
while True:
if(s[N][i][i] <= i):
break
i += 1
print(i)
```
No
| 95,237 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Problem statement
Here are $ N $ sheets of paper. You want to scan all paper by using $ 3 $ scanners in parallel. Each piece of paper has a fixed scanning time, and the time it takes to scan the $ i $ th paper is $ T_i $. You can scan the paper in any order, but you cannot scan multiple papers at the same time with a $ 1 $ scanner.
Minimize the time it takes to finish scanning all paper and run out of scanners.
Constraint
$ 1 \ leq N \ leq 50 $
$ 1 \ leq T_i \ leq 50 $
All inputs are integers
sample
Sample input 1
Four
1
1
1
1
Sample output 1
2
<image>
Sample input 2
9
15
20
27
Four
Ten
7
34
30
36
Sample output 2
61
<image>
Sample input 3
6
20
18
46
16
9
48
Sample output 3
55
<image>
input
$ N $
$ T_1 $
$ T_2 $
$ T_3 $
$ \ vdots $
$ T_N $
output
Print the answer on the $ 1 $ line.
Example
Input
4
1
1
1
1
Output
2
Submitted Solution:
```
import itertools
n=int(input())
dp=[[1<<30]*850 for _ in [0]*850]
dp[0][0]=0
t=[int(input()) for _ in[0]*n]
s=sum(t)
for i,j,k in itertools.product(range(n),range(s//3+1),range(s//2+1)):
dp[j][k]+=t[i]
if t[i]<=j and dp[j][k]>dp[j-t[i]][k]:dp[j][k]=dp[j-t[i]][k]
if t[i]<=k and dp[j][k]>dp[j][k-t[i]]:dp[j][k]=dp[j][k-t[i]]
a=1<<30
for i,j in itertools.product(range(s//3+1),range(s//2+1)):
a=min(a,max(i,j,s-i-j))
print(a)
```
No
| 95,238 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Problem statement
Here are $ N $ sheets of paper. You want to scan all paper by using $ 3 $ scanners in parallel. Each piece of paper has a fixed scanning time, and the time it takes to scan the $ i $ th paper is $ T_i $. You can scan the paper in any order, but you cannot scan multiple papers at the same time with a $ 1 $ scanner.
Minimize the time it takes to finish scanning all paper and run out of scanners.
Constraint
$ 1 \ leq N \ leq 50 $
$ 1 \ leq T_i \ leq 50 $
All inputs are integers
sample
Sample input 1
Four
1
1
1
1
Sample output 1
2
<image>
Sample input 2
9
15
20
27
Four
Ten
7
34
30
36
Sample output 2
61
<image>
Sample input 3
6
20
18
46
16
9
48
Sample output 3
55
<image>
input
$ N $
$ T_1 $
$ T_2 $
$ T_3 $
$ \ vdots $
$ T_N $
output
Print the answer on the $ 1 $ line.
Example
Input
4
1
1
1
1
Output
2
Submitted Solution:
```
# -*- coding: utf-8 -*-
N = int(input())
T = [int(input()) for i in range(N)]
T.sort(reverse = True)
machine = [0, 0, 0]
for t in T:
no = machine.index(min(machine))
machine[no] += t
print(max(machine))
```
No
| 95,239 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Problem statement
Here are $ N $ sheets of paper. You want to scan all paper by using $ 3 $ scanners in parallel. Each piece of paper has a fixed scanning time, and the time it takes to scan the $ i $ th paper is $ T_i $. You can scan the paper in any order, but you cannot scan multiple papers at the same time with a $ 1 $ scanner.
Minimize the time it takes to finish scanning all paper and run out of scanners.
Constraint
$ 1 \ leq N \ leq 50 $
$ 1 \ leq T_i \ leq 50 $
All inputs are integers
sample
Sample input 1
Four
1
1
1
1
Sample output 1
2
<image>
Sample input 2
9
15
20
27
Four
Ten
7
34
30
36
Sample output 2
61
<image>
Sample input 3
6
20
18
46
16
9
48
Sample output 3
55
<image>
input
$ N $
$ T_1 $
$ T_2 $
$ T_3 $
$ \ vdots $
$ T_N $
output
Print the answer on the $ 1 $ line.
Example
Input
4
1
1
1
1
Output
2
Submitted Solution:
```
N = int(input())
ts = [int(input()) for i in range(N)]
ts.sort()
ts.reverse()
ma = sum(ts) // 3 + 50
s = [[[0 for i in range(ma)] for j in range(ma)] for k in range(N + 1)]
for i in range(N):
for j in range(ma):
for k in range(ma):
p = [s[i][j][k] + ts[i]]
if(j >= ts[i]):
p.append(s[i][j - ts[i]][k])
if(k >= ts[i]):
p.append(s[i][j][k - ts[i]])
s[i + 1][j][k] = min(p)
i = 0
while True:
if(s[N][i][i] <= i):
break
i += 1
print(i)
```
No
| 95,240 |
Provide a correct Python 3 solution for this coding contest problem.
In the Jambo Amusement Garden (JAG), you sell colorful drinks consisting of multiple color layers. This colorful drink can be made by pouring multiple colored liquids of different density from the bottom in order.
You have already prepared several colored liquids with various colors and densities. You will receive a drink request with specified color layers. The colorful drink that you will serve must satisfy the following conditions.
* You cannot use a mixed colored liquid as a layer. Thus, for instance, you cannot create a new liquid with a new color by mixing two or more different colored liquids, nor create a liquid with a density between two or more liquids with the same color by mixing them.
* Only a colored liquid with strictly less density can be an upper layer of a denser colored liquid in a drink. That is, you can put a layer of a colored liquid with density $x$ directly above the layer of a colored liquid with density $y$ if $x < y$ holds.
Your task is to create a program to determine whether a given request can be fulfilled with the prepared colored liquids under the above conditions or not.
Input
The input consists of a single test case in the format below.
$N$
$C_1$ $D_1$
$\vdots$
$C_N$ $D_N$
$M$
$O_1$
$\vdots$
$O_M$
The first line consists of an integer $N$ ($1 \leq N \leq 10^5$), which represents the number of the prepared colored liquids. The following $N$ lines consists of $C_i$ and $D_i$ ($1 \leq i \leq N$). $C_i$ is a string consisting of lowercase alphabets and denotes the color of the $i$-th prepared colored liquid. The length of $C_i$ is between $1$ and $20$ inclusive. $D_i$ is an integer and represents the density of the $i$-th prepared colored liquid. The value of $D_i$ is between $1$ and $10^5$ inclusive. The ($N+2$)-nd line consists of an integer $M$ ($1 \leq M \leq 10^5$), which represents the number of color layers of a drink request. The following $M$ lines consists of $O_i$ ($1 \leq i \leq M$). $O_i$ is a string consisting of lowercase alphabets and denotes the color of the $i$-th layer from the top of the drink request. The length of $O_i$ is between $1$ and $20$ inclusive.
Output
If the requested colorful drink can be served by using some of the prepared colored liquids, print 'Yes'. Otherwise, print 'No'.
Examples
Input
2
white 20
black 10
2
black
white
Output
Yes
Input
2
white 10
black 10
2
black
white
Output
No
Input
2
white 20
black 10
2
black
orange
Output
No
Input
3
white 10
red 20
white 30
3
white
red
white
Output
Yes
Input
4
red 3444
red 3018
red 3098
red 3319
4
red
red
red
red
Output
Yes
"Correct Solution:
```
#!usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S(): return list(sys.stdin.readline())[:-1]
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
n = I()
d = defaultdict(lambda : [])
for i in range(n):
a,b = input().split()
b = int(b)
d[a].append(b)
for i in d.keys():
d[i].sort()
m = I()
s = 0
for i in range(m):
o = input()
if not d[o]:
print("No")
return
j = bisect.bisect_right(d[o],s)
if j == len(d[o]):
print("No")
return
s = d[o][j]
print("Yes")
return
#Solve
if __name__ == "__main__":
solve()
```
| 95,241 |
Provide a correct Python 3 solution for this coding contest problem.
In the Jambo Amusement Garden (JAG), you sell colorful drinks consisting of multiple color layers. This colorful drink can be made by pouring multiple colored liquids of different density from the bottom in order.
You have already prepared several colored liquids with various colors and densities. You will receive a drink request with specified color layers. The colorful drink that you will serve must satisfy the following conditions.
* You cannot use a mixed colored liquid as a layer. Thus, for instance, you cannot create a new liquid with a new color by mixing two or more different colored liquids, nor create a liquid with a density between two or more liquids with the same color by mixing them.
* Only a colored liquid with strictly less density can be an upper layer of a denser colored liquid in a drink. That is, you can put a layer of a colored liquid with density $x$ directly above the layer of a colored liquid with density $y$ if $x < y$ holds.
Your task is to create a program to determine whether a given request can be fulfilled with the prepared colored liquids under the above conditions or not.
Input
The input consists of a single test case in the format below.
$N$
$C_1$ $D_1$
$\vdots$
$C_N$ $D_N$
$M$
$O_1$
$\vdots$
$O_M$
The first line consists of an integer $N$ ($1 \leq N \leq 10^5$), which represents the number of the prepared colored liquids. The following $N$ lines consists of $C_i$ and $D_i$ ($1 \leq i \leq N$). $C_i$ is a string consisting of lowercase alphabets and denotes the color of the $i$-th prepared colored liquid. The length of $C_i$ is between $1$ and $20$ inclusive. $D_i$ is an integer and represents the density of the $i$-th prepared colored liquid. The value of $D_i$ is between $1$ and $10^5$ inclusive. The ($N+2$)-nd line consists of an integer $M$ ($1 \leq M \leq 10^5$), which represents the number of color layers of a drink request. The following $M$ lines consists of $O_i$ ($1 \leq i \leq M$). $O_i$ is a string consisting of lowercase alphabets and denotes the color of the $i$-th layer from the top of the drink request. The length of $O_i$ is between $1$ and $20$ inclusive.
Output
If the requested colorful drink can be served by using some of the prepared colored liquids, print 'Yes'. Otherwise, print 'No'.
Examples
Input
2
white 20
black 10
2
black
white
Output
Yes
Input
2
white 10
black 10
2
black
white
Output
No
Input
2
white 20
black 10
2
black
orange
Output
No
Input
3
white 10
red 20
white 30
3
white
red
white
Output
Yes
Input
4
red 3444
red 3018
red 3098
red 3319
4
red
red
red
red
Output
Yes
"Correct Solution:
```
import sys
liquids={}
O=[]
N = int(input())
for i in range(N):
C,D=(input().split())
if C in liquids.keys():
liquids[C].append(int(D))
else:
liquids[C]=[]
liquids[C].append(int(D))
for i in liquids.keys():
liquids[i]=list(set(liquids[i]))
liquids[i].sort()
M = int(input())
if M > N:
print("No")
sys.exit()
for i in range(M):
O.append(input())
nowdens=int(10**5+1)
for i in range(M):
try:
tmp=liquids[O[-(i+1)]]
if len(tmp)==0:
print("No")
sys.exit()
maxdens=tmp.pop()
while(maxdens>=nowdens):
if len(tmp)==0:
print("No")
sys.exit()
maxdens=tmp.pop()
nowdens=maxdens
except KeyError:
print("No")
sys.exit()
print("Yes")
```
| 95,242 |
Provide a correct Python 3 solution for this coding contest problem.
In the Jambo Amusement Garden (JAG), you sell colorful drinks consisting of multiple color layers. This colorful drink can be made by pouring multiple colored liquids of different density from the bottom in order.
You have already prepared several colored liquids with various colors and densities. You will receive a drink request with specified color layers. The colorful drink that you will serve must satisfy the following conditions.
* You cannot use a mixed colored liquid as a layer. Thus, for instance, you cannot create a new liquid with a new color by mixing two or more different colored liquids, nor create a liquid with a density between two or more liquids with the same color by mixing them.
* Only a colored liquid with strictly less density can be an upper layer of a denser colored liquid in a drink. That is, you can put a layer of a colored liquid with density $x$ directly above the layer of a colored liquid with density $y$ if $x < y$ holds.
Your task is to create a program to determine whether a given request can be fulfilled with the prepared colored liquids under the above conditions or not.
Input
The input consists of a single test case in the format below.
$N$
$C_1$ $D_1$
$\vdots$
$C_N$ $D_N$
$M$
$O_1$
$\vdots$
$O_M$
The first line consists of an integer $N$ ($1 \leq N \leq 10^5$), which represents the number of the prepared colored liquids. The following $N$ lines consists of $C_i$ and $D_i$ ($1 \leq i \leq N$). $C_i$ is a string consisting of lowercase alphabets and denotes the color of the $i$-th prepared colored liquid. The length of $C_i$ is between $1$ and $20$ inclusive. $D_i$ is an integer and represents the density of the $i$-th prepared colored liquid. The value of $D_i$ is between $1$ and $10^5$ inclusive. The ($N+2$)-nd line consists of an integer $M$ ($1 \leq M \leq 10^5$), which represents the number of color layers of a drink request. The following $M$ lines consists of $O_i$ ($1 \leq i \leq M$). $O_i$ is a string consisting of lowercase alphabets and denotes the color of the $i$-th layer from the top of the drink request. The length of $O_i$ is between $1$ and $20$ inclusive.
Output
If the requested colorful drink can be served by using some of the prepared colored liquids, print 'Yes'. Otherwise, print 'No'.
Examples
Input
2
white 20
black 10
2
black
white
Output
Yes
Input
2
white 10
black 10
2
black
white
Output
No
Input
2
white 20
black 10
2
black
orange
Output
No
Input
3
white 10
red 20
white 30
3
white
red
white
Output
Yes
Input
4
red 3444
red 3018
red 3098
red 3319
4
red
red
red
red
Output
Yes
"Correct Solution:
```
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
from functools import reduce
import sys
import math
import bisect
import random
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def LI(): return list(map(int, sys.stdin.readline().split()))
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return list(map(float, sys.stdin.readline().split()))
def LS():return sys.stdin.readline().split()
def SR(n): return [list(sys.stdin.readline())[:-1] for i in range(n)]
def IR(n): return [int(sys.stdin.readline()) for i in range(n)]
def LIR(n): return [list(map(int, sys.stdin.readline().split())) for i in range(n)]
def LSR(n): return [list(map(list, sys.stdin.readline().split())) for i in range(n)]
_gcd = lambda x, y: _gcd(y, x%y) if (x%y) else y
_lcm = lambda x, y: x*y // _gcd(x, y)
def gcd(*numbers):
return reduce(_gcd, numbers)
def lcm(*numbers):
return reduce(_lcm, numbers)
sys.setrecursionlimit(1000000)
INF = float('inf')
mod = 1000000007
dire4 = [(1,0), (0,1), (-1,0), (0,-1)]
dire8 = [(1, 0), (1, 1), (0, 1), (-1, 1), (-1, 0), (-1, -1), (0, -1), (1, -1)]
def solve(dic):
return
N = I()
dic = defaultdict(list)
for i in range(N):
C, D = LS()
D = int(D)
dic[C].append(D)
for key in dic.keys():
dic[key].sort()
M = I()
order = []
for i in range(M):
#tmp = input()
tmp = LS()[0]
order.append(tmp)
flag = True
prev = mod
if N >= M :
for layer in order[::-1] :
while True:
if len(dic[layer]) == 0 :
flag = False
break
now = dic[layer].pop(-1)
if now >= prev :
continue
else :
prev = now
break
else :
flag = False
print("Yes" if flag else "No")
```
| 95,243 |
Provide a correct Python 3 solution for this coding contest problem.
Problem
One day, Kawabayashi is about to have lunch at the school cafeteria. There are three types of daily lunch menus for school cafeterias: A lunch, B lunch, and C lunch.
Kawabayashi is a glutton, so I would like to eat all three types of daily lunch menus one by one.
However, Kawabayashi decided to put up with one type of lunch menu and eat two different types of lunch menus so as to minimize the total calorie intake with care for his health.
Ask for a lunch menu that Kawabayashi will endure when given the calories of A, B, and C lunches one day.
Constraints
The input satisfies the following conditions.
* $ 1 \ leq a, b, c \ leq 5000 $
* $ a \ neq b, b \ neq c, c \ neq a $
Input
The input is given in the following format.
$ a $ $ b $ $ c $
Three integers $ a $, $ b $, $ c $ are given, separated by spaces. Each represents the calories of A lunch, B lunch, and C lunch one day.
Output
Output the menu name that Kawabayashi will endure on one line.
"A" to put up with A lunch
"B" to put up with B lunch
"C" to put up with C lunch
Output.
Examples
Input
1000 900 850
Output
A
Input
1000 800 1200
Output
C
"Correct Solution:
```
a,b,c = map(int, input().split())
if a==max(a,b,c):
print('A')
elif b==max(a,b,c):
print('B')
else:
print('C')
```
| 95,244 |
Provide a correct Python 3 solution for this coding contest problem.
Problem
One day, Kawabayashi is about to have lunch at the school cafeteria. There are three types of daily lunch menus for school cafeterias: A lunch, B lunch, and C lunch.
Kawabayashi is a glutton, so I would like to eat all three types of daily lunch menus one by one.
However, Kawabayashi decided to put up with one type of lunch menu and eat two different types of lunch menus so as to minimize the total calorie intake with care for his health.
Ask for a lunch menu that Kawabayashi will endure when given the calories of A, B, and C lunches one day.
Constraints
The input satisfies the following conditions.
* $ 1 \ leq a, b, c \ leq 5000 $
* $ a \ neq b, b \ neq c, c \ neq a $
Input
The input is given in the following format.
$ a $ $ b $ $ c $
Three integers $ a $, $ b $, $ c $ are given, separated by spaces. Each represents the calories of A lunch, B lunch, and C lunch one day.
Output
Output the menu name that Kawabayashi will endure on one line.
"A" to put up with A lunch
"B" to put up with B lunch
"C" to put up with C lunch
Output.
Examples
Input
1000 900 850
Output
A
Input
1000 800 1200
Output
C
"Correct Solution:
```
a,b,c=map(int,input().split())
if a>b and a>c:
print("A")
elif b>c:
print("B")
else:
print("C")
```
| 95,245 |
Provide a correct Python 3 solution for this coding contest problem.
Problem
One day, Kawabayashi is about to have lunch at the school cafeteria. There are three types of daily lunch menus for school cafeterias: A lunch, B lunch, and C lunch.
Kawabayashi is a glutton, so I would like to eat all three types of daily lunch menus one by one.
However, Kawabayashi decided to put up with one type of lunch menu and eat two different types of lunch menus so as to minimize the total calorie intake with care for his health.
Ask for a lunch menu that Kawabayashi will endure when given the calories of A, B, and C lunches one day.
Constraints
The input satisfies the following conditions.
* $ 1 \ leq a, b, c \ leq 5000 $
* $ a \ neq b, b \ neq c, c \ neq a $
Input
The input is given in the following format.
$ a $ $ b $ $ c $
Three integers $ a $, $ b $, $ c $ are given, separated by spaces. Each represents the calories of A lunch, B lunch, and C lunch one day.
Output
Output the menu name that Kawabayashi will endure on one line.
"A" to put up with A lunch
"B" to put up with B lunch
"C" to put up with C lunch
Output.
Examples
Input
1000 900 850
Output
A
Input
1000 800 1200
Output
C
"Correct Solution:
```
A=list(map(int, input().split()))
print('ABC'[A.index(max(A))])
```
| 95,246 |
Provide a correct Python 3 solution for this coding contest problem.
Problem
One day, Kawabayashi is about to have lunch at the school cafeteria. There are three types of daily lunch menus for school cafeterias: A lunch, B lunch, and C lunch.
Kawabayashi is a glutton, so I would like to eat all three types of daily lunch menus one by one.
However, Kawabayashi decided to put up with one type of lunch menu and eat two different types of lunch menus so as to minimize the total calorie intake with care for his health.
Ask for a lunch menu that Kawabayashi will endure when given the calories of A, B, and C lunches one day.
Constraints
The input satisfies the following conditions.
* $ 1 \ leq a, b, c \ leq 5000 $
* $ a \ neq b, b \ neq c, c \ neq a $
Input
The input is given in the following format.
$ a $ $ b $ $ c $
Three integers $ a $, $ b $, $ c $ are given, separated by spaces. Each represents the calories of A lunch, B lunch, and C lunch one day.
Output
Output the menu name that Kawabayashi will endure on one line.
"A" to put up with A lunch
"B" to put up with B lunch
"C" to put up with C lunch
Output.
Examples
Input
1000 900 850
Output
A
Input
1000 800 1200
Output
C
"Correct Solution:
```
lst=list(map(int,input().split()))
lst2=['A','B','C']
for i,j in enumerate(lst):
if j==max(lst):
print(lst2[i])
```
| 95,247 |
Provide a correct Python 3 solution for this coding contest problem.
Problem
One day, Kawabayashi is about to have lunch at the school cafeteria. There are three types of daily lunch menus for school cafeterias: A lunch, B lunch, and C lunch.
Kawabayashi is a glutton, so I would like to eat all three types of daily lunch menus one by one.
However, Kawabayashi decided to put up with one type of lunch menu and eat two different types of lunch menus so as to minimize the total calorie intake with care for his health.
Ask for a lunch menu that Kawabayashi will endure when given the calories of A, B, and C lunches one day.
Constraints
The input satisfies the following conditions.
* $ 1 \ leq a, b, c \ leq 5000 $
* $ a \ neq b, b \ neq c, c \ neq a $
Input
The input is given in the following format.
$ a $ $ b $ $ c $
Three integers $ a $, $ b $, $ c $ are given, separated by spaces. Each represents the calories of A lunch, B lunch, and C lunch one day.
Output
Output the menu name that Kawabayashi will endure on one line.
"A" to put up with A lunch
"B" to put up with B lunch
"C" to put up with C lunch
Output.
Examples
Input
1000 900 850
Output
A
Input
1000 800 1200
Output
C
"Correct Solution:
```
a,b,c = map(int, input().split())
s = "A"
s = "B" if a < b and c < b else s
s = "C" if a < c and b < c else s
print(s)
```
| 95,248 |
Provide a correct Python 3 solution for this coding contest problem.
Problem
One day, Kawabayashi is about to have lunch at the school cafeteria. There are three types of daily lunch menus for school cafeterias: A lunch, B lunch, and C lunch.
Kawabayashi is a glutton, so I would like to eat all three types of daily lunch menus one by one.
However, Kawabayashi decided to put up with one type of lunch menu and eat two different types of lunch menus so as to minimize the total calorie intake with care for his health.
Ask for a lunch menu that Kawabayashi will endure when given the calories of A, B, and C lunches one day.
Constraints
The input satisfies the following conditions.
* $ 1 \ leq a, b, c \ leq 5000 $
* $ a \ neq b, b \ neq c, c \ neq a $
Input
The input is given in the following format.
$ a $ $ b $ $ c $
Three integers $ a $, $ b $, $ c $ are given, separated by spaces. Each represents the calories of A lunch, B lunch, and C lunch one day.
Output
Output the menu name that Kawabayashi will endure on one line.
"A" to put up with A lunch
"B" to put up with B lunch
"C" to put up with C lunch
Output.
Examples
Input
1000 900 850
Output
A
Input
1000 800 1200
Output
C
"Correct Solution:
```
# -*- coding: utf-8 -*-
a,b,c = map(int,input().split())
if a > b and a > c:
print("A")
elif b > a and b > c:
print("B")
else:
print("C")
```
| 95,249 |
Provide a correct Python 3 solution for this coding contest problem.
Problem
One day, Kawabayashi is about to have lunch at the school cafeteria. There are three types of daily lunch menus for school cafeterias: A lunch, B lunch, and C lunch.
Kawabayashi is a glutton, so I would like to eat all three types of daily lunch menus one by one.
However, Kawabayashi decided to put up with one type of lunch menu and eat two different types of lunch menus so as to minimize the total calorie intake with care for his health.
Ask for a lunch menu that Kawabayashi will endure when given the calories of A, B, and C lunches one day.
Constraints
The input satisfies the following conditions.
* $ 1 \ leq a, b, c \ leq 5000 $
* $ a \ neq b, b \ neq c, c \ neq a $
Input
The input is given in the following format.
$ a $ $ b $ $ c $
Three integers $ a $, $ b $, $ c $ are given, separated by spaces. Each represents the calories of A lunch, B lunch, and C lunch one day.
Output
Output the menu name that Kawabayashi will endure on one line.
"A" to put up with A lunch
"B" to put up with B lunch
"C" to put up with C lunch
Output.
Examples
Input
1000 900 850
Output
A
Input
1000 800 1200
Output
C
"Correct Solution:
```
a,b,c = [int(i) for i in input().split()]
if a > b and a > c:
print("A")
elif b > a and b > c:
print("B")
else:
print("C")
```
| 95,250 |
Provide a correct Python 3 solution for this coding contest problem.
Problem
One day, Kawabayashi is about to have lunch at the school cafeteria. There are three types of daily lunch menus for school cafeterias: A lunch, B lunch, and C lunch.
Kawabayashi is a glutton, so I would like to eat all three types of daily lunch menus one by one.
However, Kawabayashi decided to put up with one type of lunch menu and eat two different types of lunch menus so as to minimize the total calorie intake with care for his health.
Ask for a lunch menu that Kawabayashi will endure when given the calories of A, B, and C lunches one day.
Constraints
The input satisfies the following conditions.
* $ 1 \ leq a, b, c \ leq 5000 $
* $ a \ neq b, b \ neq c, c \ neq a $
Input
The input is given in the following format.
$ a $ $ b $ $ c $
Three integers $ a $, $ b $, $ c $ are given, separated by spaces. Each represents the calories of A lunch, B lunch, and C lunch one day.
Output
Output the menu name that Kawabayashi will endure on one line.
"A" to put up with A lunch
"B" to put up with B lunch
"C" to put up with C lunch
Output.
Examples
Input
1000 900 850
Output
A
Input
1000 800 1200
Output
C
"Correct Solution:
```
a=list(map(int, input().split()))
x=["A","B","C"]
print(x[a.index(max(a))])
```
| 95,251 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Problem
One day, Kawabayashi is about to have lunch at the school cafeteria. There are three types of daily lunch menus for school cafeterias: A lunch, B lunch, and C lunch.
Kawabayashi is a glutton, so I would like to eat all three types of daily lunch menus one by one.
However, Kawabayashi decided to put up with one type of lunch menu and eat two different types of lunch menus so as to minimize the total calorie intake with care for his health.
Ask for a lunch menu that Kawabayashi will endure when given the calories of A, B, and C lunches one day.
Constraints
The input satisfies the following conditions.
* $ 1 \ leq a, b, c \ leq 5000 $
* $ a \ neq b, b \ neq c, c \ neq a $
Input
The input is given in the following format.
$ a $ $ b $ $ c $
Three integers $ a $, $ b $, $ c $ are given, separated by spaces. Each represents the calories of A lunch, B lunch, and C lunch one day.
Output
Output the menu name that Kawabayashi will endure on one line.
"A" to put up with A lunch
"B" to put up with B lunch
"C" to put up with C lunch
Output.
Examples
Input
1000 900 850
Output
A
Input
1000 800 1200
Output
C
Submitted Solution:
```
a,b,c = input().split(" ")
if int(a) > int(b):
if int(a) > int(c):
print("A")
else:
if int(b) > int(c):
print("B")
else:
print("C")
else:
if int(b) > int(c):
print("B")
else:
print("C")
```
Yes
| 95,252 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Problem
One day, Kawabayashi is about to have lunch at the school cafeteria. There are three types of daily lunch menus for school cafeterias: A lunch, B lunch, and C lunch.
Kawabayashi is a glutton, so I would like to eat all three types of daily lunch menus one by one.
However, Kawabayashi decided to put up with one type of lunch menu and eat two different types of lunch menus so as to minimize the total calorie intake with care for his health.
Ask for a lunch menu that Kawabayashi will endure when given the calories of A, B, and C lunches one day.
Constraints
The input satisfies the following conditions.
* $ 1 \ leq a, b, c \ leq 5000 $
* $ a \ neq b, b \ neq c, c \ neq a $
Input
The input is given in the following format.
$ a $ $ b $ $ c $
Three integers $ a $, $ b $, $ c $ are given, separated by spaces. Each represents the calories of A lunch, B lunch, and C lunch one day.
Output
Output the menu name that Kawabayashi will endure on one line.
"A" to put up with A lunch
"B" to put up with B lunch
"C" to put up with C lunch
Output.
Examples
Input
1000 900 850
Output
A
Input
1000 800 1200
Output
C
Submitted Solution:
```
a, b, c = map(int, input().split())
if a > b and a > c:
print ('A')
elif b > a and b > c:
print ('B')
else:
print('C')
```
Yes
| 95,253 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Problem
One day, Kawabayashi is about to have lunch at the school cafeteria. There are three types of daily lunch menus for school cafeterias: A lunch, B lunch, and C lunch.
Kawabayashi is a glutton, so I would like to eat all three types of daily lunch menus one by one.
However, Kawabayashi decided to put up with one type of lunch menu and eat two different types of lunch menus so as to minimize the total calorie intake with care for his health.
Ask for a lunch menu that Kawabayashi will endure when given the calories of A, B, and C lunches one day.
Constraints
The input satisfies the following conditions.
* $ 1 \ leq a, b, c \ leq 5000 $
* $ a \ neq b, b \ neq c, c \ neq a $
Input
The input is given in the following format.
$ a $ $ b $ $ c $
Three integers $ a $, $ b $, $ c $ are given, separated by spaces. Each represents the calories of A lunch, B lunch, and C lunch one day.
Output
Output the menu name that Kawabayashi will endure on one line.
"A" to put up with A lunch
"B" to put up with B lunch
"C" to put up with C lunch
Output.
Examples
Input
1000 900 850
Output
A
Input
1000 800 1200
Output
C
Submitted Solution:
```
menber = ["A","B","C"]
menu = [int(x) for x in input().split() ]
print(menber[menu.index(max(menu))])
```
Yes
| 95,254 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Problem
One day, Kawabayashi is about to have lunch at the school cafeteria. There are three types of daily lunch menus for school cafeterias: A lunch, B lunch, and C lunch.
Kawabayashi is a glutton, so I would like to eat all three types of daily lunch menus one by one.
However, Kawabayashi decided to put up with one type of lunch menu and eat two different types of lunch menus so as to minimize the total calorie intake with care for his health.
Ask for a lunch menu that Kawabayashi will endure when given the calories of A, B, and C lunches one day.
Constraints
The input satisfies the following conditions.
* $ 1 \ leq a, b, c \ leq 5000 $
* $ a \ neq b, b \ neq c, c \ neq a $
Input
The input is given in the following format.
$ a $ $ b $ $ c $
Three integers $ a $, $ b $, $ c $ are given, separated by spaces. Each represents the calories of A lunch, B lunch, and C lunch one day.
Output
Output the menu name that Kawabayashi will endure on one line.
"A" to put up with A lunch
"B" to put up with B lunch
"C" to put up with C lunch
Output.
Examples
Input
1000 900 850
Output
A
Input
1000 800 1200
Output
C
Submitted Solution:
```
S = list(map(int,input().split()))
if S.index(max(S)) == 0:
print("A")
elif S.index(max(S)) == 1:
print("B")
elif S.index(max(S)) == 2:
print("C")
```
Yes
| 95,255 |
Provide a correct Python 3 solution for this coding contest problem.
For given three points p1, p2, p, find the projection point x of p onto p1p2.
<image>
Constraints
* 1 ≤ q ≤ 1000
* -10000 ≤ xi, yi ≤ 10000
* p1 and p2 are not identical.
Input
xp1 yp1 xp2 yp2
q
xp0 yp0
xp1 yp1
...
xpq−1 ypq−1
In the first line, integer coordinates of p1 and p2 are given. Then, q queries are given for integer coordinates of p.
Output
For each query, print the coordinate of the projection point x. The output values should be in a decimal fraction with an error less than 0.00000001.
Examples
Input
0 0 2 0
3
-1 1
0 1
1 1
Output
-1.0000000000 0.0000000000
0.0000000000 0.0000000000
1.0000000000 0.0000000000
Input
0 0 3 4
1
2 5
Output
3.1200000000 4.1600000000
"Correct Solution:
```
import cmath
import os
import sys
if os.getenv("LOCAL"):
sys.stdin = open("_in.txt", "r")
sys.setrecursionlimit(10 ** 9)
INF = float("inf")
IINF = 10 ** 18
MOD = 10 ** 9 + 7
# MOD = 998244353
PI = cmath.pi
TAU = cmath.pi * 2
class Point:
EPS = 1e-9
def __init__(self, c: complex):
self.c = c
@property
def x(self):
return self.c.real
@property
def y(self):
return self.c.imag
@staticmethod
def from_rect(x: float, y: float):
return Point(complex(x, y))
@staticmethod
def from_polar(r: float, phi: float):
return Point(cmath.rect(r, phi))
def __add__(self, p):
"""
:param Point p:
"""
return Point(self.c + p.c)
def __iadd__(self, p):
"""
:param Point p:
"""
self.c += p.c
return self
def __sub__(self, p):
"""
:param Point p:
"""
return Point(self.c - p.c)
def __isub__(self, p):
"""
:param Point p:
"""
self.c -= p.c
return self
def __mul__(self, f: float):
return Point(self.c * f)
def __imul__(self, f: float):
self.c *= f
return self
def __truediv__(self, f: float):
return Point(self.c / f)
def __itruediv__(self, f: float):
self.c /= f
return self
def __repr__(self):
return "({}, {})".format(round(self.x, 10), round(self.y, 10))
def __neg__(self):
return Point(-self.c)
def __eq__(self, p):
return abs(self.c - p.c) < self.EPS
def __abs__(self):
return abs(self.c)
def dot(self, p):
"""
内積
:param Point p:
:rtype: float
"""
return self.x * p.x + self.y * p.y
def det(self, p):
"""
外積
:param Point p:
:rtype: float
"""
return self.x * p.y - self.y * p.x
def dist(self, p):
"""
距離
:param Point p:
:rtype: float
"""
return abs(self.c - p.c)
def r(self):
"""
原点からの距離
:rtype: float
"""
return abs(self.c)
def phase(self):
"""
原点からの角度
:rtype: float
"""
return cmath.phase(self.c)
def angle(self, p, q):
"""
p に向かってる状態から q まで反時計回りに回転するときの角度
:param Point p:
:param Point q:
:rtype: float
"""
return (cmath.phase(q.c - self.c) - cmath.phase(p.c - self.c)) % TAU
def area(self, p, q):
"""
p, q となす三角形の面積
:param Point p:
:param Point q:
:rtype: float
"""
return abs((p - self).det(q - self) / 2)
def projection_point(self, p, q, allow_outer=False):
"""
線分 pq を通る直線上に垂線をおろしたときの足の座標
:param Point p:
:param Point q:
:param allow_outer: 答えが線分の間になくても OK
:rtype: Point|None
"""
diff_q = q - p
# p からの距離
r = (self - p).dot(diff_q) / abs(diff_q)
# 線分の角度
phase = diff_q.phase()
ret = Point.from_polar(r, phase) + p
if allow_outer or (p - ret).dot(q - ret) < self.EPS:
return ret
return None
def on_segment(self, p, q):
"""
点が線分 pq の上に乗っているか
:param Point p:
:param Point q:
:rtype: bool
"""
return abs((p - self).det(q - self)) < self.EPS and (p - self).dot(q - self) < self.EPS
p1x, p1y, p2x, p2y = list(map(int, sys.stdin.buffer.readline().split()))
Q = int(sys.stdin.buffer.readline())
XY = [list(map(int, sys.stdin.buffer.readline().split())) for _ in range(Q)]
p1 = Point.from_rect(p1x, p1y)
p2 = Point.from_rect(p2x, p2y)
for x, y in XY:
p = Point.from_rect(x, y)
ans = p.projection_point(p1, p2, allow_outer=True)
print('{:.10f} {:.10f}'.format(ans.x, ans.y))
```
| 95,256 |
Provide a correct Python 3 solution for this coding contest problem.
For given three points p1, p2, p, find the projection point x of p onto p1p2.
<image>
Constraints
* 1 ≤ q ≤ 1000
* -10000 ≤ xi, yi ≤ 10000
* p1 and p2 are not identical.
Input
xp1 yp1 xp2 yp2
q
xp0 yp0
xp1 yp1
...
xpq−1 ypq−1
In the first line, integer coordinates of p1 and p2 are given. Then, q queries are given for integer coordinates of p.
Output
For each query, print the coordinate of the projection point x. The output values should be in a decimal fraction with an error less than 0.00000001.
Examples
Input
0 0 2 0
3
-1 1
0 1
1 1
Output
-1.0000000000 0.0000000000
0.0000000000 0.0000000000
1.0000000000 0.0000000000
Input
0 0 3 4
1
2 5
Output
3.1200000000 4.1600000000
"Correct Solution:
```
x1, y1, x2, y2 = map(int, input().split())
q = int(input())
p1p2 = complex(x2 - x1, y2 - y1)
d2_p1p2 = abs(p1p2) ** 2
conj_p1p2 = p1p2.conjugate()
while q:
q -= 1
x0, y0 = map(int, input().split())
p1p0 = complex(x0 - x1, y0 - y1)
t = (conj_p1p2 * p1p0).real / d2_p1p2
print(x1 + p1p2.real * t, y1 + p1p2.imag * t)
```
| 95,257 |
Provide a correct Python 3 solution for this coding contest problem.
For given three points p1, p2, p, find the projection point x of p onto p1p2.
<image>
Constraints
* 1 ≤ q ≤ 1000
* -10000 ≤ xi, yi ≤ 10000
* p1 and p2 are not identical.
Input
xp1 yp1 xp2 yp2
q
xp0 yp0
xp1 yp1
...
xpq−1 ypq−1
In the first line, integer coordinates of p1 and p2 are given. Then, q queries are given for integer coordinates of p.
Output
For each query, print the coordinate of the projection point x. The output values should be in a decimal fraction with an error less than 0.00000001.
Examples
Input
0 0 2 0
3
-1 1
0 1
1 1
Output
-1.0000000000 0.0000000000
0.0000000000 0.0000000000
1.0000000000 0.0000000000
Input
0 0 3 4
1
2 5
Output
3.1200000000 4.1600000000
"Correct Solution:
```
#!/usr/bin/env python3
def inner_product(v1, v2):
return v1.real * v2.real + v1.imag * v2.imag
# ????????????b???????????????a??????????????´????????£?°???±???????????????????????????
def projection(a, b):
return a * inner_product(a, b) / (abs(a) ** 2)
def solve(p0, p1, p2):
a = p1 - p0
b = p2 - p0
pro = projection(a, b)
t = p0 + pro
return t
def main():
x_p0, y_p0, x_p1, y_p1 = map(float, input().split())
p0 = complex(x_p0, y_p0)
p1 = complex(x_p1, y_p1)
q = int(input())
for _ in range(q):
p2 = complex(*map(float, input().split()))
t = solve(p0, p1, p2)
print("{:.10f} {:.10f}".format(t.real, t.imag))
if __name__ == '__main__':
main()
```
| 95,258 |
Provide a correct Python 3 solution for this coding contest problem.
For given three points p1, p2, p, find the projection point x of p onto p1p2.
<image>
Constraints
* 1 ≤ q ≤ 1000
* -10000 ≤ xi, yi ≤ 10000
* p1 and p2 are not identical.
Input
xp1 yp1 xp2 yp2
q
xp0 yp0
xp1 yp1
...
xpq−1 ypq−1
In the first line, integer coordinates of p1 and p2 are given. Then, q queries are given for integer coordinates of p.
Output
For each query, print the coordinate of the projection point x. The output values should be in a decimal fraction with an error less than 0.00000001.
Examples
Input
0 0 2 0
3
-1 1
0 1
1 1
Output
-1.0000000000 0.0000000000
0.0000000000 0.0000000000
1.0000000000 0.0000000000
Input
0 0 3 4
1
2 5
Output
3.1200000000 4.1600000000
"Correct Solution:
```
#!/usr/bin/env python3
# CGL_1_A: Points/Vectors - Projection
def proj(p1, p2, p):
x1, y1 = p1
x2, y2 = p2
x, y = p
if x1 == x2:
return x1 * 1.0, y * 1.0
elif y1 == y2:
return x * 1.0, y1 * 1.0
else:
dx = x1 - x2
dy = y1 - y2
return (((dx*x + dy*y)*dx - (x1*y2 - x2*y1)*dy) / (dx*dx + dy*dy),
((dx*x + dy*y)*dy + (x1*y2 - x2*y1)*dx) / (dx*dx + dy*dy))
def run():
px1, py1, px2, py2 = [int(v) for v in input().split()]
q = int(input())
for _ in range(q):
x, y = [int(v) for v in input().split()]
print("{:.10f} {:.10f}".format(*proj((px1, py1), (px2, py2), (x, y))))
if __name__ == '__main__':
run()
```
| 95,259 |
Provide a correct Python 3 solution for this coding contest problem.
For given three points p1, p2, p, find the projection point x of p onto p1p2.
<image>
Constraints
* 1 ≤ q ≤ 1000
* -10000 ≤ xi, yi ≤ 10000
* p1 and p2 are not identical.
Input
xp1 yp1 xp2 yp2
q
xp0 yp0
xp1 yp1
...
xpq−1 ypq−1
In the first line, integer coordinates of p1 and p2 are given. Then, q queries are given for integer coordinates of p.
Output
For each query, print the coordinate of the projection point x. The output values should be in a decimal fraction with an error less than 0.00000001.
Examples
Input
0 0 2 0
3
-1 1
0 1
1 1
Output
-1.0000000000 0.0000000000
0.0000000000 0.0000000000
1.0000000000 0.0000000000
Input
0 0 3 4
1
2 5
Output
3.1200000000 4.1600000000
"Correct Solution:
```
import math
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 __repr__(self):
return f"({self.x},{self.y})"
class Segment:
def __init__(self, x: Point, y: Point):
self.pt1 = x
self.pt2 = y
self.vector = self.pt2 - self.pt1
self.norm = pow(self.vector.x, 2) + pow(self.vector.y, 2)
self.abs = math.sqrt(self.norm)
def dot(self, other):
return self.vector.x * other.vector.x + self.vector.y * other.vector.y
def cross(self, other):
return self.vector.x * other.vector.y - self.vector.y * other.vector.x
def projection(self, pt: Point)-> Point:
vec_p1_to_pt = Segment(self.pt1, pt)
t = self.dot(vec_p1_to_pt) / self.abs
x = self.pt1.x + t / self.abs * self.vector.x
y = self.pt1.y + t / self.abs * self.vector.y
return Point(x, y)
def __repr__(self):
return f"{self.pt1},{self.pt2},{self.vector}"
def main():
p0_x, p0_y, p1_x, p1_y = map(int, input().split())
seg_1 = Segment(Point(p0_x, p0_y), Point(p1_x, p1_y))
num_query = int(input())
for i in range(num_query):
pt_x , pt_y = map(int, input().split())
proj = seg_1.projection(Point(pt_x, pt_y))
print("{:.10f} {:.10f}".format(proj.x, proj.y))
return
main()
```
| 95,260 |
Provide a correct Python 3 solution for this coding contest problem.
For given three points p1, p2, p, find the projection point x of p onto p1p2.
<image>
Constraints
* 1 ≤ q ≤ 1000
* -10000 ≤ xi, yi ≤ 10000
* p1 and p2 are not identical.
Input
xp1 yp1 xp2 yp2
q
xp0 yp0
xp1 yp1
...
xpq−1 ypq−1
In the first line, integer coordinates of p1 and p2 are given. Then, q queries are given for integer coordinates of p.
Output
For each query, print the coordinate of the projection point x. The output values should be in a decimal fraction with an error less than 0.00000001.
Examples
Input
0 0 2 0
3
-1 1
0 1
1 1
Output
-1.0000000000 0.0000000000
0.0000000000 0.0000000000
1.0000000000 0.0000000000
Input
0 0 3 4
1
2 5
Output
3.1200000000 4.1600000000
"Correct Solution:
```
L1=input().split( )
[xp1,yp1,xp2,yp2]=[int(L1[0]),int(L1[1]),int(L1[2]),int(L1[3])]
direction=[xp2-xp1,yp2-yp1]
norm_direc=[(xp2-xp1)/((xp2-xp1)**2+(yp2-yp1)**2)**(1/2),(yp2-yp1)/((xp2-xp1)**2+(yp2-yp1)**2)**(1/2)]
q=int(input())
L=[]
for i in range(q):
L2=input().split( )
L.append([int(L2[0]),int(L2[1])])
Point=[]
for i in range(q):
Point.append([(L[i][0]-xp1),(L[i][1]-yp1)])
Vec=[]
for i in range(q):
Vec.append([L[i][0]-xp1,L[i][1]-yp1])
Proj=[]
for i in range(q):
inter=Vec[i][0]*norm_direc[0]+Vec[i][1]*norm_direc[1]
Proj.append([norm_direc[0]*inter,norm_direc[1]*inter])
L2=[]
for i in range(q):
L2.append([xp1+Proj[i][0],yp1+Proj[i][1]])
for i in range(q):
print(*L2[i])
```
| 95,261 |
Provide a correct Python 3 solution for this coding contest problem.
For given three points p1, p2, p, find the projection point x of p onto p1p2.
<image>
Constraints
* 1 ≤ q ≤ 1000
* -10000 ≤ xi, yi ≤ 10000
* p1 and p2 are not identical.
Input
xp1 yp1 xp2 yp2
q
xp0 yp0
xp1 yp1
...
xpq−1 ypq−1
In the first line, integer coordinates of p1 and p2 are given. Then, q queries are given for integer coordinates of p.
Output
For each query, print the coordinate of the projection point x. The output values should be in a decimal fraction with an error less than 0.00000001.
Examples
Input
0 0 2 0
3
-1 1
0 1
1 1
Output
-1.0000000000 0.0000000000
0.0000000000 0.0000000000
1.0000000000 0.0000000000
Input
0 0 3 4
1
2 5
Output
3.1200000000 4.1600000000
"Correct Solution:
```
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
input:
0 0 3 4
1
2 5
output:
3.1200000000 4.1600000000
"""
import sys
def solve(_prj_info):
for point in _prj_info:
xp, yp = map(int, point)
p = xp + yp * 1j
hypo = p - p1
prj = p1 + base * project(base, hypo)
print('{0:.10f} {1:.10f}'.format(prj.real, prj.imag))
return _prj_info
def dot(a, b):
return a.real * b.real + a.imag * b.imag
def project(a, b):
return dot(a, b) / dot(a, a)
if __name__ == '__main__':
_input = sys.stdin.readlines()
base_info = _input[0].split()
q_num = int(_input[1])
prj_points = map(lambda x: x.split(), _input[2:])
x1, y1, x2, y2 = map(int, base_info)
p1, p2 = x1 + y1 * 1j, x2 + y2 * 1j
base = p2 - p1
res = solve(prj_points)
```
| 95,262 |
Provide a correct Python 3 solution for this coding contest problem.
For given three points p1, p2, p, find the projection point x of p onto p1p2.
<image>
Constraints
* 1 ≤ q ≤ 1000
* -10000 ≤ xi, yi ≤ 10000
* p1 and p2 are not identical.
Input
xp1 yp1 xp2 yp2
q
xp0 yp0
xp1 yp1
...
xpq−1 ypq−1
In the first line, integer coordinates of p1 and p2 are given. Then, q queries are given for integer coordinates of p.
Output
For each query, print the coordinate of the projection point x. The output values should be in a decimal fraction with an error less than 0.00000001.
Examples
Input
0 0 2 0
3
-1 1
0 1
1 1
Output
-1.0000000000 0.0000000000
0.0000000000 0.0000000000
1.0000000000 0.0000000000
Input
0 0 3 4
1
2 5
Output
3.1200000000 4.1600000000
"Correct Solution:
```
from math import hypot
x1, y1, x2, y2 = map(int, input().split())
dx, dy = x2-x1, y2-y1
vector_a = hypot(dx, dy)
q = int(input())
for x3, y3 in (map(int, input().split()) for _ in [0]*q):
d = ((x3-x1)*dx + (y3-y1)*dy) / (vector_a**2)
print(x1+dx*d, y1+dy*d)
```
| 95,263 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
For given three points p1, p2, p, find the projection point x of p onto p1p2.
<image>
Constraints
* 1 ≤ q ≤ 1000
* -10000 ≤ xi, yi ≤ 10000
* p1 and p2 are not identical.
Input
xp1 yp1 xp2 yp2
q
xp0 yp0
xp1 yp1
...
xpq−1 ypq−1
In the first line, integer coordinates of p1 and p2 are given. Then, q queries are given for integer coordinates of p.
Output
For each query, print the coordinate of the projection point x. The output values should be in a decimal fraction with an error less than 0.00000001.
Examples
Input
0 0 2 0
3
-1 1
0 1
1 1
Output
-1.0000000000 0.0000000000
0.0000000000 0.0000000000
1.0000000000 0.0000000000
Input
0 0 3 4
1
2 5
Output
3.1200000000 4.1600000000
Submitted Solution:
```
from decimal import Decimal as D
a,s,d,f=map(D,input().split())
h=[d-a,f-s]
leh=((d-a)**2+(f-s)**2)**(D("0.5"))
for i in range(int(input())):
x,y=map(D,input().split())
co=(x-a)*h[0]/leh+(y-s)*h[1]/leh
print(a+h[0]*co/leh,s+h[1]*co/leh)
```
Yes
| 95,264 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
For given three points p1, p2, p, find the projection point x of p onto p1p2.
<image>
Constraints
* 1 ≤ q ≤ 1000
* -10000 ≤ xi, yi ≤ 10000
* p1 and p2 are not identical.
Input
xp1 yp1 xp2 yp2
q
xp0 yp0
xp1 yp1
...
xpq−1 ypq−1
In the first line, integer coordinates of p1 and p2 are given. Then, q queries are given for integer coordinates of p.
Output
For each query, print the coordinate of the projection point x. The output values should be in a decimal fraction with an error less than 0.00000001.
Examples
Input
0 0 2 0
3
-1 1
0 1
1 1
Output
-1.0000000000 0.0000000000
0.0000000000 0.0000000000
1.0000000000 0.0000000000
Input
0 0 3 4
1
2 5
Output
3.1200000000 4.1600000000
Submitted Solution:
```
# -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=CGL_1_A&lang=jp
"""
import sys
from sys import stdin
input = stdin.readline
class Point(object):
epsilon = 1e-10
def __init__(self, x=0.0, y=0.0):
if isinstance(x, tuple):
self.x = x[0]
self.y = x[1]
else:
self.x = x
self.y = y
# ????????????
def __add__(self, other):
return Point(self.x + other.x, self.y + other.y)
def __sub__(self, other):
return Point(self.x - other.x, self.y - other.y)
def __mul__(self, other):
return Point(other * self.x, other * self.y)
def __truediv__(self, other):
return Point(other / self.x, other / self.y)
def __lt__(self, other):
if self.x == other.x:
return self.y < other.y
else:
return self.x < other.x
def __eq__(self, other):
from math import fabs
if fabs(self.x - other.x) < Point.epsilon and fabs(self.y - other.y) < Point.epsilon:
return True
else:
return False
def norm(self):
return self.x * self.x + self.y * self.y
def abs(self):
from math import sqrt
return sqrt(self.norm())
class Vector(Point):
def __init__(self, x=0.0, y=0.0):
if isinstance(x, tuple):
self.x = x[0]
self.y = x[1]
elif isinstance(x, Point):
self.x = x.x
self.y = x.y
else:
self.x = x
self.y = y
# ????????????
def __add__(self, other):
return Vector(self.x + other.x, self.y + other.y)
def __sub__(self, other):
return Vector(self.x - other.x, self.y - other.y)
def __mul__(self, other):
return Vector(other * self.x, other * self.y)
def __truediv__(self, other):
return Vector(other / self.x, other / self.y)
@classmethod
def dot(cls, a, b):
return a.x * b.x + a.y * b.y
@classmethod
def cross(cls, a, b):
return a.x * b.y - a.y * b.x
@classmethod
def is_orthogonal(cls, a, b):
return Vector.dot(a, b) == 0.0
@classmethod
def is_parallel(cls, a, b):
return Vector.cross(a, b) == 0.0
class Segment(object):
def __init__(self, p1=Point(), p2=Point()):
if isinstance(p1, Point):
self.p1 = p1
self.p2 = p2
elif isinstance(p1, tuple):
self.p1 = Point(p1[0], p1[1])
self.p2 = Point(p2[0], p2[1])
@classmethod
def is_orthogonal(cls, s1, s2):
a = Vector(s1.p2 - s1.p1)
b = Vector(s2.p2 - s2.p1)
return Vector.is_orthogonal(a, b)
@classmethod
def is_parallel(cls, s1, s2):
a = Vector(s1.p2 - s1.p1)
b = Vector(s2.p2 - s2.p1)
return Vector.is_parallel(a, b)
class Line(Segment):
pass
class Cirle(object):
def __init__(self, c=Point(), r=0.0):
self.c = c
self.r = r
def solve(s, p):
base = Vector(s.p2 - s.p1)
a = Vector(p - s.p1)
r = Vector.dot(a, base)
r /= base.norm()
return s.p1 + base * r
def main(args):
x_p1, y_p1, x_p2, y_p2 = map(int, input().split())
q = int(input())
s = Segment((x_p1, y_p1), (x_p2, y_p2))
for _ in range(q):
x, y = map(int, input().split())
p = Point(x, y)
result = solve(s, p)
print('{:.10f} {:.10f}'.format(result.x, result.y))
if __name__ == '__main__':
main(sys.argv[1:])
```
Yes
| 95,265 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
For given three points p1, p2, p, find the projection point x of p onto p1p2.
<image>
Constraints
* 1 ≤ q ≤ 1000
* -10000 ≤ xi, yi ≤ 10000
* p1 and p2 are not identical.
Input
xp1 yp1 xp2 yp2
q
xp0 yp0
xp1 yp1
...
xpq−1 ypq−1
In the first line, integer coordinates of p1 and p2 are given. Then, q queries are given for integer coordinates of p.
Output
For each query, print the coordinate of the projection point x. The output values should be in a decimal fraction with an error less than 0.00000001.
Examples
Input
0 0 2 0
3
-1 1
0 1
1 1
Output
-1.0000000000 0.0000000000
0.0000000000 0.0000000000
1.0000000000 0.0000000000
Input
0 0 3 4
1
2 5
Output
3.1200000000 4.1600000000
Submitted Solution:
```
from sys import stdin
readline = stdin.readline
def main():
x1, y1, x2, y2 = map(int, readline().split())
p1, p2 = x1 + y1 * 1j, x2 + y2 * 1j
for i in range(int(readline())):
xi, yi = map(int, readline().split())
pi = xi + yi * 1j
cross = p1 + (p2 - p1) * projecter(p2 - p1, pi - p1)
print('{:.10f} {:.10f}'.format(cross.real, cross.imag))
def projecter(a, b):
return dot(a, b) / dot(a, a)
def dot(a, b):
return a.real * b.real + a.imag * b.imag
main()
```
Yes
| 95,266 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
For given three points p1, p2, p, find the projection point x of p onto p1p2.
<image>
Constraints
* 1 ≤ q ≤ 1000
* -10000 ≤ xi, yi ≤ 10000
* p1 and p2 are not identical.
Input
xp1 yp1 xp2 yp2
q
xp0 yp0
xp1 yp1
...
xpq−1 ypq−1
In the first line, integer coordinates of p1 and p2 are given. Then, q queries are given for integer coordinates of p.
Output
For each query, print the coordinate of the projection point x. The output values should be in a decimal fraction with an error less than 0.00000001.
Examples
Input
0 0 2 0
3
-1 1
0 1
1 1
Output
-1.0000000000 0.0000000000
0.0000000000 0.0000000000
1.0000000000 0.0000000000
Input
0 0 3 4
1
2 5
Output
3.1200000000 4.1600000000
Submitted Solution:
```
from math import hypot
x1, y1, x2, y2 = map(int, input().split())
dx, dy = x2-x1, y2-y1
vector_base = hypot(dx, dy)
q = int(input())
for i in range(q):
x3, y3 = map(int, input().split())
d = ((x3-x1)*dx + (y3-y1)*dy) / (vector_base**2)
print(x1+dx*d, y1+dy*d)
```
Yes
| 95,267 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
For given three points p1, p2, p, find the projection point x of p onto p1p2.
<image>
Constraints
* 1 ≤ q ≤ 1000
* -10000 ≤ xi, yi ≤ 10000
* p1 and p2 are not identical.
Input
xp1 yp1 xp2 yp2
q
xp0 yp0
xp1 yp1
...
xpq−1 ypq−1
In the first line, integer coordinates of p1 and p2 are given. Then, q queries are given for integer coordinates of p.
Output
For each query, print the coordinate of the projection point x. The output values should be in a decimal fraction with an error less than 0.00000001.
Examples
Input
0 0 2 0
3
-1 1
0 1
1 1
Output
-1.0000000000 0.0000000000
0.0000000000 0.0000000000
1.0000000000 0.0000000000
Input
0 0 3 4
1
2 5
Output
3.1200000000 4.1600000000
Submitted Solution:
```
def dot(a, b):
return a.real * b.real + a.imag * b.imag
def projection(a, b):
return a * dot(a, b) / (abs(a) ** 2)
#複素平面の座標はクラスだから直接加算できr
def solve(p0,p1,p2):
a=p1-p0
b=p2-p0
pro=projection(a,b)
t=p0+pro
return t
def main():
x0,y0,x1,y1=map(float,input().split())
p0=complex(x0,y0)
p1=complex(x1,y1)
q=int(input())
for i in range(q):
p2=complex(*map(float,input().split()))
t=solve(p0,p1,p2)
print('{:.10f}{:.10f}'.format(t.real,t.imag))
if __name__ == '__main__':
main()
```
No
| 95,268 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
For given three points p1, p2, p, find the projection point x of p onto p1p2.
<image>
Constraints
* 1 ≤ q ≤ 1000
* -10000 ≤ xi, yi ≤ 10000
* p1 and p2 are not identical.
Input
xp1 yp1 xp2 yp2
q
xp0 yp0
xp1 yp1
...
xpq−1 ypq−1
In the first line, integer coordinates of p1 and p2 are given. Then, q queries are given for integer coordinates of p.
Output
For each query, print the coordinate of the projection point x. The output values should be in a decimal fraction with an error less than 0.00000001.
Examples
Input
0 0 2 0
3
-1 1
0 1
1 1
Output
-1.0000000000 0.0000000000
0.0000000000 0.0000000000
1.0000000000 0.0000000000
Input
0 0 3 4
1
2 5
Output
3.1200000000 4.1600000000
Submitted Solution:
```
# Aizu Problem CGL_1_A: Projection
#
import sys, math, os
# read input:
PYDEV = os.environ.get('PYDEV')
if PYDEV=="True":
sys.stdin = open("sample-input3.txt", "rt")
x1, y1, x2, y2 = [int(_) for _ in input().split()]
sx = x2 - x1
sy = y2 - y1
s_sq = sx**2 + sy**2
Q = int(input())
for q in range(Q):
px, py = [int(_) for _ in input().split()]
if y1 == y2:
x = px
y = y1
else:
x = x1 + (px * sx + py * sy) * sx / s_sq
y = y1 + (px * sx + py * sy) * sy / s_sq
print("%.10f %.10f" % (x, y))
```
No
| 95,269 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
For given three points p1, p2, p, find the projection point x of p onto p1p2.
<image>
Constraints
* 1 ≤ q ≤ 1000
* -10000 ≤ xi, yi ≤ 10000
* p1 and p2 are not identical.
Input
xp1 yp1 xp2 yp2
q
xp0 yp0
xp1 yp1
...
xpq−1 ypq−1
In the first line, integer coordinates of p1 and p2 are given. Then, q queries are given for integer coordinates of p.
Output
For each query, print the coordinate of the projection point x. The output values should be in a decimal fraction with an error less than 0.00000001.
Examples
Input
0 0 2 0
3
-1 1
0 1
1 1
Output
-1.0000000000 0.0000000000
0.0000000000 0.0000000000
1.0000000000 0.0000000000
Input
0 0 3 4
1
2 5
Output
3.1200000000 4.1600000000
Submitted Solution:
```
def dot(a, b):
return a.real * b.real + a.imag * b.imag
def projection(a, b):
return a * dot(a, b) / (abs(a) ** 2)
#複素平面の座標はクラスだから直接加算できr
def solve(p0,p1,p2):
a=p1-p0
b=p2-p0
pro=projection(a,b)
t=p0+pro
return t
def main():
x0,y0,x1,y1=map(float,input().split())
p0=complex(x0,y0)
p1=complex(x1,y1)
q=int(input())
for i in range(q):
p2=complex(*map(float,input().split()))
t=solve(p0,p1,p2)
print('{:.10f}{:.10f}'.format(t.real,t.imag))
main()
```
No
| 95,270 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
For given three points p1, p2, p, find the projection point x of p onto p1p2.
<image>
Constraints
* 1 ≤ q ≤ 1000
* -10000 ≤ xi, yi ≤ 10000
* p1 and p2 are not identical.
Input
xp1 yp1 xp2 yp2
q
xp0 yp0
xp1 yp1
...
xpq−1 ypq−1
In the first line, integer coordinates of p1 and p2 are given. Then, q queries are given for integer coordinates of p.
Output
For each query, print the coordinate of the projection point x. The output values should be in a decimal fraction with an error less than 0.00000001.
Examples
Input
0 0 2 0
3
-1 1
0 1
1 1
Output
-1.0000000000 0.0000000000
0.0000000000 0.0000000000
1.0000000000 0.0000000000
Input
0 0 3 4
1
2 5
Output
3.1200000000 4.1600000000
Submitted Solution:
```
def dot(a,b):
return a[0]*b[0] + a[1]*b[1]
x1,y1,x2,y2 = [int(i) for i in input().split()]
q = int(input())
for i in range(q):
x,y = [int(i) for i in input().split()]
a = [x2-x1,y2-y1]
b = [x-x1,y-y1]
co = dot(a,b) / dot(a,a)
print(a[0]*co,a[1]*co)
```
No
| 95,271 |
Provide a correct Python 3 solution for this coding contest problem.
Priority queue is a container of elements which the element with the highest priority should be extracted first.
For $n$ priority queues $Q_i$ ($i = 0, 1, ..., n-1$) of integers, perform a sequence of the following operations.
* insert($t$, $x$): Insert $x$ to $Q_t$.
* getMax($t$): Report the maximum value in $Q_t$. If $Q_t$ is empty, do nothing.
* deleteMax($t$): Delete the maximum element from $Q_t$. If $Q_t$ is empty, do nothing.
In the initial state, all queues are empty.
Constraints
* $1 \leq n \leq 1,000$
* $1 \leq q \leq 200,000$
* $-1,000,000,000 \leq x \leq 1,000,000,000$
Input
The input is given in the following format.
$n \; q$
$query_1$
$query_2$
:
$query_q$
Each query $query_i$ is given by
0 $t$ $x$
or
1 $t$
or
2 $t$
where the first digits 0, 1 and 2 represent insert, getMax and deleteMax operations respectively.
Output
For each getMax operation, print an integer in a line.
Example
Input
2 10
0 0 3
0 0 9
0 0 1
1 0
2 0
1 0
0 0 4
1 0
0 1 8
1 1
Output
9
3
4
8
"Correct Solution:
```
import sys
import heapq
n, q = map(int, input().split())
Q = [[] for _ in range(n)]
ans = []
heapq.heapify(Q)
for query in (line.split() for line in sys.stdin):
t = int(query[1])
if query[0] == '0':
u = int(query[2])
heapq.heappush(Q[t], -u)
elif query[0] == '1' and Q[t]:
ans.append(-Q[t][0])
elif query[0] == '2' and Q[t]:
heapq.heappop(Q[t])
for i in ans:
print(i)
```
| 95,272 |
Provide a correct Python 3 solution for this coding contest problem.
Priority queue is a container of elements which the element with the highest priority should be extracted first.
For $n$ priority queues $Q_i$ ($i = 0, 1, ..., n-1$) of integers, perform a sequence of the following operations.
* insert($t$, $x$): Insert $x$ to $Q_t$.
* getMax($t$): Report the maximum value in $Q_t$. If $Q_t$ is empty, do nothing.
* deleteMax($t$): Delete the maximum element from $Q_t$. If $Q_t$ is empty, do nothing.
In the initial state, all queues are empty.
Constraints
* $1 \leq n \leq 1,000$
* $1 \leq q \leq 200,000$
* $-1,000,000,000 \leq x \leq 1,000,000,000$
Input
The input is given in the following format.
$n \; q$
$query_1$
$query_2$
:
$query_q$
Each query $query_i$ is given by
0 $t$ $x$
or
1 $t$
or
2 $t$
where the first digits 0, 1 and 2 represent insert, getMax and deleteMax operations respectively.
Output
For each getMax operation, print an integer in a line.
Example
Input
2 10
0 0 3
0 0 9
0 0 1
1 0
2 0
1 0
0 0 4
1 0
0 1 8
1 1
Output
9
3
4
8
"Correct Solution:
```
from heapq import heappush, heappop
n, q = list(map(int, input().split(' ')))
pqueues = [[] for i in range(n)]
for i in range(q):
op = list(map(int, input().split(' ')))
if op[0] == 0:
heappush(pqueues[op[1]], -op[2])
elif op[0] == 1:
if len(pqueues[op[1]]) != 0:
print(-1*pqueues[op[1]][0])
elif op[0] == 2:
if len(pqueues[op[1]]) != 0:
heappop(pqueues[op[1]])
```
| 95,273 |
Provide a correct Python 3 solution for this coding contest problem.
Priority queue is a container of elements which the element with the highest priority should be extracted first.
For $n$ priority queues $Q_i$ ($i = 0, 1, ..., n-1$) of integers, perform a sequence of the following operations.
* insert($t$, $x$): Insert $x$ to $Q_t$.
* getMax($t$): Report the maximum value in $Q_t$. If $Q_t$ is empty, do nothing.
* deleteMax($t$): Delete the maximum element from $Q_t$. If $Q_t$ is empty, do nothing.
In the initial state, all queues are empty.
Constraints
* $1 \leq n \leq 1,000$
* $1 \leq q \leq 200,000$
* $-1,000,000,000 \leq x \leq 1,000,000,000$
Input
The input is given in the following format.
$n \; q$
$query_1$
$query_2$
:
$query_q$
Each query $query_i$ is given by
0 $t$ $x$
or
1 $t$
or
2 $t$
where the first digits 0, 1 and 2 represent insert, getMax and deleteMax operations respectively.
Output
For each getMax operation, print an integer in a line.
Example
Input
2 10
0 0 3
0 0 9
0 0 1
1 0
2 0
1 0
0 0 4
1 0
0 1 8
1 1
Output
9
3
4
8
"Correct Solution:
```
class MaxHeapInt(object):
def __init__(self, val): self.val = val
def __lt__(self, other): return self.val > other.val
def __eq__(self, other): return self.val == other.val
def __str__(self): return str(self.val)
def resolve():
import heapq
n, Q = [int(i) for i in input().split()]
ans = [[] for _ in range(n)]
for _ in range(Q):
q = [int(i) for i in input().split()]
if q[0] == 0:
heapq.heappush(ans[q[1]], MaxHeapInt(q[2]))
elif q[0] == 1:
if len(ans[q[1]]) > 0:
print(ans[q[1]][0].val)
else:
if len(ans[q[1]]) > 0:
heapq.heappop(ans[q[1]])
resolve()
```
| 95,274 |
Provide a correct Python 3 solution for this coding contest problem.
Priority queue is a container of elements which the element with the highest priority should be extracted first.
For $n$ priority queues $Q_i$ ($i = 0, 1, ..., n-1$) of integers, perform a sequence of the following operations.
* insert($t$, $x$): Insert $x$ to $Q_t$.
* getMax($t$): Report the maximum value in $Q_t$. If $Q_t$ is empty, do nothing.
* deleteMax($t$): Delete the maximum element from $Q_t$. If $Q_t$ is empty, do nothing.
In the initial state, all queues are empty.
Constraints
* $1 \leq n \leq 1,000$
* $1 \leq q \leq 200,000$
* $-1,000,000,000 \leq x \leq 1,000,000,000$
Input
The input is given in the following format.
$n \; q$
$query_1$
$query_2$
:
$query_q$
Each query $query_i$ is given by
0 $t$ $x$
or
1 $t$
or
2 $t$
where the first digits 0, 1 and 2 represent insert, getMax and deleteMax operations respectively.
Output
For each getMax operation, print an integer in a line.
Example
Input
2 10
0 0 3
0 0 9
0 0 1
1 0
2 0
1 0
0 0 4
1 0
0 1 8
1 1
Output
9
3
4
8
"Correct Solution:
```
# AOJ ITP2_2_C: Priority Queue
# Python3 2018.6.24 bal4u
import heapq
n, q = map(int, input().split())
Q = [[] for i in range(n)]
for i in range(q):
a = input().split()
t = int(a[1])
if a[0] == '0': heapq.heappush(Q[t], -int(a[2])) # insert
elif a[0] == '1' and Q[t]: print(-Q[t][0]) # getMax
elif a[0] == '2' and Q[t]: heapq.heappop(Q[t]) # deleteMax
```
| 95,275 |
Provide a correct Python 3 solution for this coding contest problem.
Priority queue is a container of elements which the element with the highest priority should be extracted first.
For $n$ priority queues $Q_i$ ($i = 0, 1, ..., n-1$) of integers, perform a sequence of the following operations.
* insert($t$, $x$): Insert $x$ to $Q_t$.
* getMax($t$): Report the maximum value in $Q_t$. If $Q_t$ is empty, do nothing.
* deleteMax($t$): Delete the maximum element from $Q_t$. If $Q_t$ is empty, do nothing.
In the initial state, all queues are empty.
Constraints
* $1 \leq n \leq 1,000$
* $1 \leq q \leq 200,000$
* $-1,000,000,000 \leq x \leq 1,000,000,000$
Input
The input is given in the following format.
$n \; q$
$query_1$
$query_2$
:
$query_q$
Each query $query_i$ is given by
0 $t$ $x$
or
1 $t$
or
2 $t$
where the first digits 0, 1 and 2 represent insert, getMax and deleteMax operations respectively.
Output
For each getMax operation, print an integer in a line.
Example
Input
2 10
0 0 3
0 0 9
0 0 1
1 0
2 0
1 0
0 0 4
1 0
0 1 8
1 1
Output
9
3
4
8
"Correct Solution:
```
import heapq
n, q = [int(x) for x in input().split()]
L = [ [] for _ in range(n)]
for _ in range(q):
c, t, x = [int(x) for x in (input()+ " 0").split()][:3]
if c == 0:
heapq.heappush(L[t],-x)
elif c == 1:
try:
print(-L[t][0])
except IndexError:
pass
else:
try:
heapq.heappop(L[t])
except IndexError:
pass
```
| 95,276 |
Provide a correct Python 3 solution for this coding contest problem.
Priority queue is a container of elements which the element with the highest priority should be extracted first.
For $n$ priority queues $Q_i$ ($i = 0, 1, ..., n-1$) of integers, perform a sequence of the following operations.
* insert($t$, $x$): Insert $x$ to $Q_t$.
* getMax($t$): Report the maximum value in $Q_t$. If $Q_t$ is empty, do nothing.
* deleteMax($t$): Delete the maximum element from $Q_t$. If $Q_t$ is empty, do nothing.
In the initial state, all queues are empty.
Constraints
* $1 \leq n \leq 1,000$
* $1 \leq q \leq 200,000$
* $-1,000,000,000 \leq x \leq 1,000,000,000$
Input
The input is given in the following format.
$n \; q$
$query_1$
$query_2$
:
$query_q$
Each query $query_i$ is given by
0 $t$ $x$
or
1 $t$
or
2 $t$
where the first digits 0, 1 and 2 represent insert, getMax and deleteMax operations respectively.
Output
For each getMax operation, print an integer in a line.
Example
Input
2 10
0 0 3
0 0 9
0 0 1
1 0
2 0
1 0
0 0 4
1 0
0 1 8
1 1
Output
9
3
4
8
"Correct Solution:
```
# http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=ITP2_2_C&lang=jp
# Priority Queue
from collections import deque
import sys
input = sys.stdin.readline
import heapq
def loop_proc():
(n1,n2) = map(int,input().split())
wl =[]
for i in range(n1):
wl.append(list())
for i in range(n2):
l = list(map(int,input().split()))
if (l[0] == 0 ):
n = l[1]
d = l[2]
heapq.heappush(wl[n],-1 * d)
elif (l[0] == 1 ):
if ( len(wl[l[1]]) != 0 ):
tl = wl[l[1]]
a = heapq.heappop(tl)
heapq.heappush(tl,a)
print (int(a) * -1 )
elif (l[0] == 2 ):
if ( len(wl[l[1]]) != 0 ):
tl = wl[l[1]]
heapq.heappop(tl)
if __name__ == '__main__':
loop_proc()
# import cProfile
# pr = cProfile.Profile()
# pr.runcall(loop_proc)
# pr.print_stats()
```
| 95,277 |
Provide a correct Python 3 solution for this coding contest problem.
Priority queue is a container of elements which the element with the highest priority should be extracted first.
For $n$ priority queues $Q_i$ ($i = 0, 1, ..., n-1$) of integers, perform a sequence of the following operations.
* insert($t$, $x$): Insert $x$ to $Q_t$.
* getMax($t$): Report the maximum value in $Q_t$. If $Q_t$ is empty, do nothing.
* deleteMax($t$): Delete the maximum element from $Q_t$. If $Q_t$ is empty, do nothing.
In the initial state, all queues are empty.
Constraints
* $1 \leq n \leq 1,000$
* $1 \leq q \leq 200,000$
* $-1,000,000,000 \leq x \leq 1,000,000,000$
Input
The input is given in the following format.
$n \; q$
$query_1$
$query_2$
:
$query_q$
Each query $query_i$ is given by
0 $t$ $x$
or
1 $t$
or
2 $t$
where the first digits 0, 1 and 2 represent insert, getMax and deleteMax operations respectively.
Output
For each getMax operation, print an integer in a line.
Example
Input
2 10
0 0 3
0 0 9
0 0 1
1 0
2 0
1 0
0 0 4
1 0
0 1 8
1 1
Output
9
3
4
8
"Correct Solution:
```
import heapq
n, q = map(int, input().split())
stack = [[] for _ in range(n)]
heapq.heapify(stack)
for _ in range(q):
query = list(map(int, input().split()))
if query[0] == 0:
heapq.heappush(stack[query[1]], -query[2])
elif query[0] == 1:
if stack[query[1]] == []:
pass
else:
print(-stack[query[1]][0])
elif query[0] == 2:
if stack[query[1]] == []:
pass
else:
heapq.heappop(stack[query[1]])
```
| 95,278 |
Provide a correct Python 3 solution for this coding contest problem.
Priority queue is a container of elements which the element with the highest priority should be extracted first.
For $n$ priority queues $Q_i$ ($i = 0, 1, ..., n-1$) of integers, perform a sequence of the following operations.
* insert($t$, $x$): Insert $x$ to $Q_t$.
* getMax($t$): Report the maximum value in $Q_t$. If $Q_t$ is empty, do nothing.
* deleteMax($t$): Delete the maximum element from $Q_t$. If $Q_t$ is empty, do nothing.
In the initial state, all queues are empty.
Constraints
* $1 \leq n \leq 1,000$
* $1 \leq q \leq 200,000$
* $-1,000,000,000 \leq x \leq 1,000,000,000$
Input
The input is given in the following format.
$n \; q$
$query_1$
$query_2$
:
$query_q$
Each query $query_i$ is given by
0 $t$ $x$
or
1 $t$
or
2 $t$
where the first digits 0, 1 and 2 represent insert, getMax and deleteMax operations respectively.
Output
For each getMax operation, print an integer in a line.
Example
Input
2 10
0 0 3
0 0 9
0 0 1
1 0
2 0
1 0
0 0 4
1 0
0 1 8
1 1
Output
9
3
4
8
"Correct Solution:
```
import sys
import heapq
n, q = map(int, input().split())
queues = {str(i): [] for i in range(n)}
lines = sys.stdin.readlines()
for i in range(q):
query, *arg = lines[i].split()
if query == '0': # insert t x
heapq.heappush(queues[arg[0]], -int(arg[1]))
elif query == '1': # getMax
if len(queues[arg[0]]):
print(-queues[arg[0]][0])
elif query == '2': # deleteMax
if len(queues[arg[0]]):
heapq.heappop(queues[arg[0]])
else:
raise AssertionError
```
| 95,279 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Priority queue is a container of elements which the element with the highest priority should be extracted first.
For $n$ priority queues $Q_i$ ($i = 0, 1, ..., n-1$) of integers, perform a sequence of the following operations.
* insert($t$, $x$): Insert $x$ to $Q_t$.
* getMax($t$): Report the maximum value in $Q_t$. If $Q_t$ is empty, do nothing.
* deleteMax($t$): Delete the maximum element from $Q_t$. If $Q_t$ is empty, do nothing.
In the initial state, all queues are empty.
Constraints
* $1 \leq n \leq 1,000$
* $1 \leq q \leq 200,000$
* $-1,000,000,000 \leq x \leq 1,000,000,000$
Input
The input is given in the following format.
$n \; q$
$query_1$
$query_2$
:
$query_q$
Each query $query_i$ is given by
0 $t$ $x$
or
1 $t$
or
2 $t$
where the first digits 0, 1 and 2 represent insert, getMax and deleteMax operations respectively.
Output
For each getMax operation, print an integer in a line.
Example
Input
2 10
0 0 3
0 0 9
0 0 1
1 0
2 0
1 0
0 0 4
1 0
0 1 8
1 1
Output
9
3
4
8
Submitted Solution:
```
import bisect
n, q = map(int, input().split())
Q = [[] for i in range(n)]
for i in range(q):
query = list(map(int, input().split()))
if query[0] == 0: bisect.insort_left(Q[query[1]], query[2])
elif query[0] == 1 and len(Q[query[1]]): print(Q[query[1]][-1])
elif query[0] == 2 and len(Q[query[1]]): Q[query[1]].pop(-1)
```
Yes
| 95,280 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Priority queue is a container of elements which the element with the highest priority should be extracted first.
For $n$ priority queues $Q_i$ ($i = 0, 1, ..., n-1$) of integers, perform a sequence of the following operations.
* insert($t$, $x$): Insert $x$ to $Q_t$.
* getMax($t$): Report the maximum value in $Q_t$. If $Q_t$ is empty, do nothing.
* deleteMax($t$): Delete the maximum element from $Q_t$. If $Q_t$ is empty, do nothing.
In the initial state, all queues are empty.
Constraints
* $1 \leq n \leq 1,000$
* $1 \leq q \leq 200,000$
* $-1,000,000,000 \leq x \leq 1,000,000,000$
Input
The input is given in the following format.
$n \; q$
$query_1$
$query_2$
:
$query_q$
Each query $query_i$ is given by
0 $t$ $x$
or
1 $t$
or
2 $t$
where the first digits 0, 1 and 2 represent insert, getMax and deleteMax operations respectively.
Output
For each getMax operation, print an integer in a line.
Example
Input
2 10
0 0 3
0 0 9
0 0 1
1 0
2 0
1 0
0 0 4
1 0
0 1 8
1 1
Output
9
3
4
8
Submitted Solution:
```
import heapq
n,q = map(int,input().split())
Q = [[] for i in range(n)]
for i in range(q):
a = input().split()
t = int(a[1])
if a[0] == "0":heapq.heappush(Q[t],-int(a[2]))
elif a[0] == "1" and Q[t]: print(-Q[t][0])
elif a[0] == "2" and Q[t]: heapq.heappop(Q[t])
```
Yes
| 95,281 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Priority queue is a container of elements which the element with the highest priority should be extracted first.
For $n$ priority queues $Q_i$ ($i = 0, 1, ..., n-1$) of integers, perform a sequence of the following operations.
* insert($t$, $x$): Insert $x$ to $Q_t$.
* getMax($t$): Report the maximum value in $Q_t$. If $Q_t$ is empty, do nothing.
* deleteMax($t$): Delete the maximum element from $Q_t$. If $Q_t$ is empty, do nothing.
In the initial state, all queues are empty.
Constraints
* $1 \leq n \leq 1,000$
* $1 \leq q \leq 200,000$
* $-1,000,000,000 \leq x \leq 1,000,000,000$
Input
The input is given in the following format.
$n \; q$
$query_1$
$query_2$
:
$query_q$
Each query $query_i$ is given by
0 $t$ $x$
or
1 $t$
or
2 $t$
where the first digits 0, 1 and 2 represent insert, getMax and deleteMax operations respectively.
Output
For each getMax operation, print an integer in a line.
Example
Input
2 10
0 0 3
0 0 9
0 0 1
1 0
2 0
1 0
0 0 4
1 0
0 1 8
1 1
Output
9
3
4
8
Submitted Solution:
```
import sys
input = sys.stdin.readline
import heapq
N,Q = map(int,input().split())
H = [[] for _ in range(N)]
for _ in range(Q):
q = list(map(int,input().split()))
if q[0] == 0:
heapq.heappush(H[q[1]],-q[2])
elif q[0] == 1:
if H[q[1]]:
print(-H[q[1]][0])
else:
if H[q[1]]:
heapq.heappop(H[q[1]])
```
Yes
| 95,282 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Priority queue is a container of elements which the element with the highest priority should be extracted first.
For $n$ priority queues $Q_i$ ($i = 0, 1, ..., n-1$) of integers, perform a sequence of the following operations.
* insert($t$, $x$): Insert $x$ to $Q_t$.
* getMax($t$): Report the maximum value in $Q_t$. If $Q_t$ is empty, do nothing.
* deleteMax($t$): Delete the maximum element from $Q_t$. If $Q_t$ is empty, do nothing.
In the initial state, all queues are empty.
Constraints
* $1 \leq n \leq 1,000$
* $1 \leq q \leq 200,000$
* $-1,000,000,000 \leq x \leq 1,000,000,000$
Input
The input is given in the following format.
$n \; q$
$query_1$
$query_2$
:
$query_q$
Each query $query_i$ is given by
0 $t$ $x$
or
1 $t$
or
2 $t$
where the first digits 0, 1 and 2 represent insert, getMax and deleteMax operations respectively.
Output
For each getMax operation, print an integer in a line.
Example
Input
2 10
0 0 3
0 0 9
0 0 1
1 0
2 0
1 0
0 0 4
1 0
0 1 8
1 1
Output
9
3
4
8
Submitted Solution:
```
import sys
from collections import defaultdict
from heapq import heappop, heappush
n = int(sys.stdin.readline().split()[0])
A = defaultdict(list)
ans = []
for query in sys.stdin:
if query[0] == '0':
t, x = query[2:].split()
heappush(A[t], -int(x))
elif query[0] == '1':
if A[query[2:-1]]:
ans.append(f'{-A[query[2:-1]][0]}' + '\n')
else:
if A[query[2:-1]]:
heappop(A[query[2:-1]])
sys.stdout.writelines(ans)
```
Yes
| 95,283 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Priority queue is a container of elements which the element with the highest priority should be extracted first.
For $n$ priority queues $Q_i$ ($i = 0, 1, ..., n-1$) of integers, perform a sequence of the following operations.
* insert($t$, $x$): Insert $x$ to $Q_t$.
* getMax($t$): Report the maximum value in $Q_t$. If $Q_t$ is empty, do nothing.
* deleteMax($t$): Delete the maximum element from $Q_t$. If $Q_t$ is empty, do nothing.
In the initial state, all queues are empty.
Constraints
* $1 \leq n \leq 1,000$
* $1 \leq q \leq 200,000$
* $-1,000,000,000 \leq x \leq 1,000,000,000$
Input
The input is given in the following format.
$n \; q$
$query_1$
$query_2$
:
$query_q$
Each query $query_i$ is given by
0 $t$ $x$
or
1 $t$
or
2 $t$
where the first digits 0, 1 and 2 represent insert, getMax and deleteMax operations respectively.
Output
For each getMax operation, print an integer in a line.
Example
Input
2 10
0 0 3
0 0 9
0 0 1
1 0
2 0
1 0
0 0 4
1 0
0 1 8
1 1
Output
9
3
4
8
Submitted Solution:
```
from heapq import heappush, heappop, heapify
if __name__ == '__main__':
n, q = input().split()
n, q = int(n), int(q)
S = [[] for i in range(n)]
for i in range(q):
query = input().split()
if query[0] == '0':
St = S[int(query[1])]
#print(type(St), St, query[1])
heappush(St, int(query[2]))
#print(St, heapify(St))
S[int(query[1])] = sorted(St)
#print(S)
else:
if len(S[int(query[1])]) == 0:
pass
elif query[0] == '1':
print(S[int(query[1])][-1])
else:
S[int(query[1])].pop()
```
No
| 95,284 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Priority queue is a container of elements which the element with the highest priority should be extracted first.
For $n$ priority queues $Q_i$ ($i = 0, 1, ..., n-1$) of integers, perform a sequence of the following operations.
* insert($t$, $x$): Insert $x$ to $Q_t$.
* getMax($t$): Report the maximum value in $Q_t$. If $Q_t$ is empty, do nothing.
* deleteMax($t$): Delete the maximum element from $Q_t$. If $Q_t$ is empty, do nothing.
In the initial state, all queues are empty.
Constraints
* $1 \leq n \leq 1,000$
* $1 \leq q \leq 200,000$
* $-1,000,000,000 \leq x \leq 1,000,000,000$
Input
The input is given in the following format.
$n \; q$
$query_1$
$query_2$
:
$query_q$
Each query $query_i$ is given by
0 $t$ $x$
or
1 $t$
or
2 $t$
where the first digits 0, 1 and 2 represent insert, getMax and deleteMax operations respectively.
Output
For each getMax operation, print an integer in a line.
Example
Input
2 10
0 0 3
0 0 9
0 0 1
1 0
2 0
1 0
0 0 4
1 0
0 1 8
1 1
Output
9
3
4
8
Submitted Solution:
```
# -*- coding: utf-8 -*-
"""
Created on Sun Jun 24 18:23:54 2018
ITP22C
@author: maezawa
"""
n, q = list(map(int, input().split()))
a = [[] for _ in range(n)]
for i in range(q):
c = list(map(int, input().split()))
if c[0] == 0:
if a[c[1]]:
if a[c[1]][-1] < c[2]:
a[c[1]].append(c[2])
else:
for j in reversed(range(len(a[c[1]])-1)):
if a[c[1]][j] < c[2]:
a[c[1]].insert(j+1, c[2])
break
else:
a[c[1]].append(c[2])
elif c[0] == 1:
if a[c[1]]:
print(a[c[1]][-1])
else:
if a[c[1]]:
a[c[1]].pop()
```
No
| 95,285 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Priority queue is a container of elements which the element with the highest priority should be extracted first.
For $n$ priority queues $Q_i$ ($i = 0, 1, ..., n-1$) of integers, perform a sequence of the following operations.
* insert($t$, $x$): Insert $x$ to $Q_t$.
* getMax($t$): Report the maximum value in $Q_t$. If $Q_t$ is empty, do nothing.
* deleteMax($t$): Delete the maximum element from $Q_t$. If $Q_t$ is empty, do nothing.
In the initial state, all queues are empty.
Constraints
* $1 \leq n \leq 1,000$
* $1 \leq q \leq 200,000$
* $-1,000,000,000 \leq x \leq 1,000,000,000$
Input
The input is given in the following format.
$n \; q$
$query_1$
$query_2$
:
$query_q$
Each query $query_i$ is given by
0 $t$ $x$
or
1 $t$
or
2 $t$
where the first digits 0, 1 and 2 represent insert, getMax and deleteMax operations respectively.
Output
For each getMax operation, print an integer in a line.
Example
Input
2 10
0 0 3
0 0 9
0 0 1
1 0
2 0
1 0
0 0 4
1 0
0 1 8
1 1
Output
9
3
4
8
Submitted Solution:
```
# -*- coding: utf-8 -*-
"""
Created on Sun Jun 24 18:23:54 2018
ITP22C
@author: maezawa
"""
n, q = list(map(int, input().split()))
a = [[] for _ in range(n)]
for i in range(q):
c = list(map(int, input().split()))
if c[0] == 0:
a[c[1]].append(c[2])
elif c[0] == 1:
if a[c[1]]:
print(max(a[c[1]]))
else:
if a[c[1]]:
m = max(a[c[1]])
a[c[1]].remove(m)
```
No
| 95,286 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Priority queue is a container of elements which the element with the highest priority should be extracted first.
For $n$ priority queues $Q_i$ ($i = 0, 1, ..., n-1$) of integers, perform a sequence of the following operations.
* insert($t$, $x$): Insert $x$ to $Q_t$.
* getMax($t$): Report the maximum value in $Q_t$. If $Q_t$ is empty, do nothing.
* deleteMax($t$): Delete the maximum element from $Q_t$. If $Q_t$ is empty, do nothing.
In the initial state, all queues are empty.
Constraints
* $1 \leq n \leq 1,000$
* $1 \leq q \leq 200,000$
* $-1,000,000,000 \leq x \leq 1,000,000,000$
Input
The input is given in the following format.
$n \; q$
$query_1$
$query_2$
:
$query_q$
Each query $query_i$ is given by
0 $t$ $x$
or
1 $t$
or
2 $t$
where the first digits 0, 1 and 2 represent insert, getMax and deleteMax operations respectively.
Output
For each getMax operation, print an integer in a line.
Example
Input
2 10
0 0 3
0 0 9
0 0 1
1 0
2 0
1 0
0 0 4
1 0
0 1 8
1 1
Output
9
3
4
8
Submitted Solution:
```
class binaryTree:
def __init__(self, root = None):
self.value = root
self.left = None
self.right = None
def makeBntr(bnary, num):
if bnary is None or bnary.value is None:
return binaryTree(num)
elif bnary.value is None:
return binaryTree(num)
elif bnary.value < num:
bnary.left = makeBntr(bnary.left, num)
else:
bnary.right = makeBntr(bnary.right, num)
return bnary
def maxLeaf(bnary):
if bnary.value is None:
return 0
elif bnary.left is not None:
return maxLeaf(bnary.left)
else:
return bnary
def getLeaf(bnary):
return maxLeaf(bnary).value
def mkBntr(bnary, num):
if bnary is None:
return num
elif bnary.value < num.value:
bnary.left = mkBntr(bnary.left, num)
else:
bnary.right = mkBntr(bnary.right, num)
return bnary
def toLeft(bnary):
if bnary.left is None:
right = bnary.right
bnary = None
return bnary, right
else:
bnary.left, right = toLeft(bnary.left)
return bnary, right
def delLeaf(bnary):
bnary, right = toLeft(bnary)
if bnary is None:
bnary = binaryTree()
return bnary if right is None else mkBntr(bnary, right)
if __name__ == '__main__':
n, q = input().split()
n, q = int(n), int(q)
S = [binaryTree() for i in range(n)]
count = 1
for i in range(q):
query = input().split()
if query[1] != "12":
continue
count += 1
bnary = S[int(query[1])]
if query[0] == '0':
S[int(query[1])] = makeBntr(bnary, int(query[2]))
else:
if bnary.value is None:
pass
elif query[0] == '1':
print(getLeaf(bnary))
else:
S[int(query[1])] = delLeaf(bnary)
```
No
| 95,287 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
It is the year 2969. 1000 years have passed from the moon landing. Meanwhile, the humanity colonized the Hyperspace™ and lived in harmony.
Until we realized that we were not alone.
Not too far away from the Earth, the massive fleet of aliens' spaceships is preparing to attack the Earth. For the first time in a while, the humanity is in real danger. Crisis and panic are everywhere. The scientists from all around the solar system have met and discussed the possible solutions. However, no progress has been made.
The Earth's last hope is YOU!
Fortunately, the Earth is equipped with very powerful defense systems made by MDCS. There are N aliens' spaceships which form the line. The defense system consists of three types of weapons:
* SQL rockets – every SQL rocket can destroy at most one spaceship in the given set.
* Cognition beams – every Cognition beam has an interval [l,r] and can destroy at most one spaceship in that interval.
* OMG bazooka – every OMG bazooka has three possible targets, however, each bazooka can destroy either zero or exactly two spaceships. In addition, due to the smart targeting system, the sets of the three possible targets of any two different OMG bazookas are disjoint (that means that every ship is targeted with at most one OMG bazooka).
Your task is to make a plan of the attack which will destroy the largest possible number of spaceships. Every destroyed spaceship should be destroyed with exactly one weapon.
Input
The first line contains two integers: the number of your weapons N (1≤ N≤ 5000) and the number of spaceships M (1≤ M≤ 5000).
In the next N lines, each line starts with one integer that represents type (either 0, 1 or 2). If the type is 0, then the weapon is SQL rocket, the rest of the line contains strictly positive number K (∑{K} ≤ 100 000) and array k_i (1≤ k_i≤ M) of K integers. If the type is 1, then the weapon is Cognition beam, the rest of the line contains integers l and r (1≤ l≤ r≤ M). If the type is 2 then the weapon is OMG bazooka, the rest of the line contains distinct numbers a, b and c (1 ≤ a,b,c ≤ M).
Output
The first line should contain the maximum number of destroyed spaceships — X.
In the next X lines, every line should contain two numbers A and B, where A is an index of the weapon and B is an index of the spaceship which was destroyed by the weapon A.
Example
Input
3 5
0 1 4
2 5 4 1
1 1 4
Output
4
2 1
3 2
1 4
2 5
Note
SQL rocket can destroy only 4th spaceship. OMG Bazooka can destroy two of 1st, 4th or 5th spaceship, and Cognition beam can destroy any spaceship from the interval [1,4]. The maximum number of destroyed spaceship is 4, and one possible plan is that SQL rocket should destroy 4th spaceship, OMG bazooka should destroy 1st and 5th spaceship and Cognition beam should destroy 2nd spaceship.
Submitted Solution:
```
line1 = list(map(int,input().split(' ')))
n = line1[0]
m = line1[1]
line2 = list(map(int,input().split(' ')))
line3 = list(map(int,input().split(' ')))
line4 = list(map(int,input().split(' ')))
weapon = []
weapon.append(line2[0])
weapon.append(line3[0])
weapon.append(line4[0])
weapon.sort()
#weapon.reverse()
t = []
for i in range(0,3):
if weapon[i] is line2[0]:
t.append(line2)
elif weapon[i] is line3[0]:
t.append(line3)
elif weapon[i] is line4[0]:
t.append(line4)
print("t = ",t)
x = 1
bz = 0
sq = []
at = []
m =[]
for i in range(2,-1,-1):
if i is 2:
x=2
for j in range(1,4):
if t[2][j] in t[0]:
m.append(t[2][j])
m.sort()
for c in range(1,4):
if bz<2:
if t[2][c] in m:
break
else:
at.append(t[2][c])
bz+=1
sq.append(x)
if bz<2:
if m[0] not in at:
at.append(m[0])
sq.append(x)
if i is 0:
x=1
bz=0
for c in range(1,3):
if t[0][c] not in at:
if bz is 0:
at.append(t[0][c])
sq.append(x)
bz+=1
bz=0
for i in range(t[1][1],t[1][2]+1):
if bz is 0:
if i not in at:
at.append(i)
sq.append(3)
bz+=1
print(len(at))
for i in range(0,4):
print("%d %d"%(sq[i],at[i]))
```
No
| 95,288 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
It is the year 2969. 1000 years have passed from the moon landing. Meanwhile, the humanity colonized the Hyperspace™ and lived in harmony.
Until we realized that we were not alone.
Not too far away from the Earth, the massive fleet of aliens' spaceships is preparing to attack the Earth. For the first time in a while, the humanity is in real danger. Crisis and panic are everywhere. The scientists from all around the solar system have met and discussed the possible solutions. However, no progress has been made.
The Earth's last hope is YOU!
Fortunately, the Earth is equipped with very powerful defense systems made by MDCS. There are N aliens' spaceships which form the line. The defense system consists of three types of weapons:
* SQL rockets – every SQL rocket can destroy at most one spaceship in the given set.
* Cognition beams – every Cognition beam has an interval [l,r] and can destroy at most one spaceship in that interval.
* OMG bazooka – every OMG bazooka has three possible targets, however, each bazooka can destroy either zero or exactly two spaceships. In addition, due to the smart targeting system, the sets of the three possible targets of any two different OMG bazookas are disjoint (that means that every ship is targeted with at most one OMG bazooka).
Your task is to make a plan of the attack which will destroy the largest possible number of spaceships. Every destroyed spaceship should be destroyed with exactly one weapon.
Input
The first line contains two integers: the number of your weapons N (1≤ N≤ 5000) and the number of spaceships M (1≤ M≤ 5000).
In the next N lines, each line starts with one integer that represents type (either 0, 1 or 2). If the type is 0, then the weapon is SQL rocket, the rest of the line contains strictly positive number K (∑{K} ≤ 100 000) and array k_i (1≤ k_i≤ M) of K integers. If the type is 1, then the weapon is Cognition beam, the rest of the line contains integers l and r (1≤ l≤ r≤ M). If the type is 2 then the weapon is OMG bazooka, the rest of the line contains distinct numbers a, b and c (1 ≤ a,b,c ≤ M).
Output
The first line should contain the maximum number of destroyed spaceships — X.
In the next X lines, every line should contain two numbers A and B, where A is an index of the weapon and B is an index of the spaceship which was destroyed by the weapon A.
Example
Input
3 5
0 1 4
2 5 4 1
1 1 4
Output
4
2 1
3 2
1 4
2 5
Note
SQL rocket can destroy only 4th spaceship. OMG Bazooka can destroy two of 1st, 4th or 5th spaceship, and Cognition beam can destroy any spaceship from the interval [1,4]. The maximum number of destroyed spaceship is 4, and one possible plan is that SQL rocket should destroy 4th spaceship, OMG bazooka should destroy 1st and 5th spaceship and Cognition beam should destroy 2nd spaceship.
Submitted Solution:
```
line1 = list(map(int,input().split(' ')))
n = line1[0]
m = line1[1]
line2 = list(map(int,input().split(' ')))
line3 = list(map(int,input().split(' ')))
line4 = list(map(int,input().split(' ')))
weapon = []
weapon.append(line2[0])
weapon.append(line3[0])
weapon.append(line4[0])
weapon.sort()
#weapon.reverse()
t = []
for i in range(0,3):
if weapon[i] is line2[0]:
t.append(line2)
elif weapon[i] is line3[0]:
t.append(line3)
elif weapon[i] is line4[0]:
t.append(line4)
print("t = ",t)
x = 1
bz = 0
sq = []
at = []
m =[]
for i in range(2,-1,-1):
if i is 2:
x=2
for j in range(1,4):
if t[2][j] in t[0]:
m.append(t[2][j])
m.sort()
for c in range(1,4):
if bz<2:
if t[2][c] in m:
break
else:
at.append(t[2][c])
bz+=1
sq.append(x)
if bz<2:
if m[0] not in at:
at.append(m[0])
sq.append(x)
if i is 0:
x=1
bz=0
for c in range(1,3):
if t[0][c] not in at:
if bz is 0:
at.append(t[0][c])
sq.append(x)
bz+=1
bz=0
for i in range(t[1][1],t[1][2]+1):
if bz is 0:
if i not in at:
at.append(i)
sq.append(3)
bz+=1
print(len(at))
fat = []
# fat.append(at[0])
# fat.append(at[3])
# fat.append(at[2])
# fat.append(at[1])
fsq = []
# fsq.append(sq[0])
# fsq.append(sq[3])
# fsq.append(sq[2])
# fsq.append(sq[1])
test = 0
for i in range(0,4):
for j in range(0,4):
if at[j]>at[i]:
test = at[j]
at[j] = at[i]
at[i] = test
test = sq[j]
sq[j] = sq[i]
sq[i] = test
for i in range(0,4):
print("%d %d"%(sq[i],at[i]))
```
No
| 95,289 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ivan is collecting coins. There are only N different collectible coins, Ivan has K of them. He will be celebrating his birthday soon, so all his M freinds decided to gift him coins. They all agreed to three terms:
* Everyone must gift as many coins as others.
* All coins given to Ivan must be different.
* Not less than L coins from gifts altogether, must be new in Ivan's collection.
But his friends don't know which coins have Ivan already got in his collection. They don't want to spend money so they want to buy minimum quantity of coins, that satisfy all terms, irrespective of the Ivan's collection. Help them to find this minimum number of coins or define it's not possible to meet all the terms.
Input
The only line of input contains 4 integers N, M, K, L (1 ≤ K ≤ N ≤ 10^{18}; 1 ≤ M, L ≤ 10^{18}) — quantity of different coins, number of Ivan's friends, size of Ivan's collection and quantity of coins, that must be new in Ivan's collection.
Output
Print one number — minimal number of coins one friend can gift to satisfy all the conditions. If it is impossible to satisfy all three conditions print "-1" (without quotes).
Examples
Input
20 15 2 3
Output
1
Input
10 11 2 4
Output
-1
Note
In the first test, one coin from each friend is enough, as he will be presented with 15 different coins and 13 of them will definitely be new.
In the second test, Ivan has 11 friends, but there are only 10 different coins. So all friends can't present him different coins.
Tags: math
Correct Solution:
```
n, m, k, l = [int(i) for i in input().split()]
if k + l> n:
print(-1)
else:
x = (k+l)//m
if (k + l)% m != 0:
x += 1
if m * x >n:
print(-1)
else:
print(x)#different coins m
```
| 95,290 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ivan is collecting coins. There are only N different collectible coins, Ivan has K of them. He will be celebrating his birthday soon, so all his M freinds decided to gift him coins. They all agreed to three terms:
* Everyone must gift as many coins as others.
* All coins given to Ivan must be different.
* Not less than L coins from gifts altogether, must be new in Ivan's collection.
But his friends don't know which coins have Ivan already got in his collection. They don't want to spend money so they want to buy minimum quantity of coins, that satisfy all terms, irrespective of the Ivan's collection. Help them to find this minimum number of coins or define it's not possible to meet all the terms.
Input
The only line of input contains 4 integers N, M, K, L (1 ≤ K ≤ N ≤ 10^{18}; 1 ≤ M, L ≤ 10^{18}) — quantity of different coins, number of Ivan's friends, size of Ivan's collection and quantity of coins, that must be new in Ivan's collection.
Output
Print one number — minimal number of coins one friend can gift to satisfy all the conditions. If it is impossible to satisfy all three conditions print "-1" (without quotes).
Examples
Input
20 15 2 3
Output
1
Input
10 11 2 4
Output
-1
Note
In the first test, one coin from each friend is enough, as he will be presented with 15 different coins and 13 of them will definitely be new.
In the second test, Ivan has 11 friends, but there are only 10 different coins. So all friends can't present him different coins.
Tags: math
Correct Solution:
```
import math
if __name__ == '__main__':
n,m,k,l = [int (x) for x in input().split()]
if (n- k < l ) :
print(-1)
elif ( m > n) :
print(-1)
elif k+l < m:
print (1)
else :
if (k+l)%m == 0:
print ( (k+l)//m )
elif ((k+l)//m + 1 )*m <= n :
print((k+l)//m + 1)
else:
print(-1)
```
| 95,291 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ivan is collecting coins. There are only N different collectible coins, Ivan has K of them. He will be celebrating his birthday soon, so all his M freinds decided to gift him coins. They all agreed to three terms:
* Everyone must gift as many coins as others.
* All coins given to Ivan must be different.
* Not less than L coins from gifts altogether, must be new in Ivan's collection.
But his friends don't know which coins have Ivan already got in his collection. They don't want to spend money so they want to buy minimum quantity of coins, that satisfy all terms, irrespective of the Ivan's collection. Help them to find this minimum number of coins or define it's not possible to meet all the terms.
Input
The only line of input contains 4 integers N, M, K, L (1 ≤ K ≤ N ≤ 10^{18}; 1 ≤ M, L ≤ 10^{18}) — quantity of different coins, number of Ivan's friends, size of Ivan's collection and quantity of coins, that must be new in Ivan's collection.
Output
Print one number — minimal number of coins one friend can gift to satisfy all the conditions. If it is impossible to satisfy all three conditions print "-1" (without quotes).
Examples
Input
20 15 2 3
Output
1
Input
10 11 2 4
Output
-1
Note
In the first test, one coin from each friend is enough, as he will be presented with 15 different coins and 13 of them will definitely be new.
In the second test, Ivan has 11 friends, but there are only 10 different coins. So all friends can't present him different coins.
Tags: math
Correct Solution:
```
n,m,k,L = map(int,input().split())
l,r = 0, n//m
while l <= r:
mid = (l+r)//2
if(m*mid - k >= L):
r = mid-1
else:
l = mid+1
l = min(l,n//m)
if(m*l - k >= L):
print(l)
else:
print("-1")
```
| 95,292 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ivan is collecting coins. There are only N different collectible coins, Ivan has K of them. He will be celebrating his birthday soon, so all his M freinds decided to gift him coins. They all agreed to three terms:
* Everyone must gift as many coins as others.
* All coins given to Ivan must be different.
* Not less than L coins from gifts altogether, must be new in Ivan's collection.
But his friends don't know which coins have Ivan already got in his collection. They don't want to spend money so they want to buy minimum quantity of coins, that satisfy all terms, irrespective of the Ivan's collection. Help them to find this minimum number of coins or define it's not possible to meet all the terms.
Input
The only line of input contains 4 integers N, M, K, L (1 ≤ K ≤ N ≤ 10^{18}; 1 ≤ M, L ≤ 10^{18}) — quantity of different coins, number of Ivan's friends, size of Ivan's collection and quantity of coins, that must be new in Ivan's collection.
Output
Print one number — minimal number of coins one friend can gift to satisfy all the conditions. If it is impossible to satisfy all three conditions print "-1" (without quotes).
Examples
Input
20 15 2 3
Output
1
Input
10 11 2 4
Output
-1
Note
In the first test, one coin from each friend is enough, as he will be presented with 15 different coins and 13 of them will definitely be new.
In the second test, Ivan has 11 friends, but there are only 10 different coins. So all friends can't present him different coins.
Tags: math
Correct Solution:
```
n, m, k, l = list(map(int, input().split()))
if m > n:
print(-1)
exit()
per = n // m
uk1 = 0
if (per * m) >=l+k:
while per - uk1 > 1 :
if ((uk1 + per)//2 * m) < l+k :
uk1 = (uk1 + per)//2
elif ((uk1 + per) // 2 * m) >= l+k:
per = (uk1 + per) // 2
print(per)
else:
print(-1)
```
| 95,293 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ivan is collecting coins. There are only N different collectible coins, Ivan has K of them. He will be celebrating his birthday soon, so all his M freinds decided to gift him coins. They all agreed to three terms:
* Everyone must gift as many coins as others.
* All coins given to Ivan must be different.
* Not less than L coins from gifts altogether, must be new in Ivan's collection.
But his friends don't know which coins have Ivan already got in his collection. They don't want to spend money so they want to buy minimum quantity of coins, that satisfy all terms, irrespective of the Ivan's collection. Help them to find this minimum number of coins or define it's not possible to meet all the terms.
Input
The only line of input contains 4 integers N, M, K, L (1 ≤ K ≤ N ≤ 10^{18}; 1 ≤ M, L ≤ 10^{18}) — quantity of different coins, number of Ivan's friends, size of Ivan's collection and quantity of coins, that must be new in Ivan's collection.
Output
Print one number — minimal number of coins one friend can gift to satisfy all the conditions. If it is impossible to satisfy all three conditions print "-1" (without quotes).
Examples
Input
20 15 2 3
Output
1
Input
10 11 2 4
Output
-1
Note
In the first test, one coin from each friend is enough, as he will be presented with 15 different coins and 13 of them will definitely be new.
In the second test, Ivan has 11 friends, but there are only 10 different coins. So all friends can't present him different coins.
Tags: math
Correct Solution:
```
def print_return(func):
def wrapper(*args, **kwargs):
retval = func(*args, **kwargs)
print(retval)
return retval
return wrapper
class Solve:
@print_return
# @staticmethod
def solve_a(lines=None):
if lines is None:
n, m, k, l = (int(x) for x in input().split())
else:
n, m, k, l = (int(x) for x in lines[0].split())
x = k + l + m - 1
x //= m
if x * m > n:
return -1
return x
if __name__ == '__main__':
Solve.solve_a()
```
| 95,294 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ivan is collecting coins. There are only N different collectible coins, Ivan has K of them. He will be celebrating his birthday soon, so all his M freinds decided to gift him coins. They all agreed to three terms:
* Everyone must gift as many coins as others.
* All coins given to Ivan must be different.
* Not less than L coins from gifts altogether, must be new in Ivan's collection.
But his friends don't know which coins have Ivan already got in his collection. They don't want to spend money so they want to buy minimum quantity of coins, that satisfy all terms, irrespective of the Ivan's collection. Help them to find this minimum number of coins or define it's not possible to meet all the terms.
Input
The only line of input contains 4 integers N, M, K, L (1 ≤ K ≤ N ≤ 10^{18}; 1 ≤ M, L ≤ 10^{18}) — quantity of different coins, number of Ivan's friends, size of Ivan's collection and quantity of coins, that must be new in Ivan's collection.
Output
Print one number — minimal number of coins one friend can gift to satisfy all the conditions. If it is impossible to satisfy all three conditions print "-1" (without quotes).
Examples
Input
20 15 2 3
Output
1
Input
10 11 2 4
Output
-1
Note
In the first test, one coin from each friend is enough, as he will be presented with 15 different coins and 13 of them will definitely be new.
In the second test, Ivan has 11 friends, but there are only 10 different coins. So all friends can't present him different coins.
Tags: math
Correct Solution:
```
def Main():
total, friends, collection, limit = map(int, input().split())
mn = (collection + limit + friends - 1) // friends
if(mn * friends <= total):
print(mn)
else :
print('-1')
t = 1
for _ in range(t):
Main()
```
| 95,295 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ivan is collecting coins. There are only N different collectible coins, Ivan has K of them. He will be celebrating his birthday soon, so all his M freinds decided to gift him coins. They all agreed to three terms:
* Everyone must gift as many coins as others.
* All coins given to Ivan must be different.
* Not less than L coins from gifts altogether, must be new in Ivan's collection.
But his friends don't know which coins have Ivan already got in his collection. They don't want to spend money so they want to buy minimum quantity of coins, that satisfy all terms, irrespective of the Ivan's collection. Help them to find this minimum number of coins or define it's not possible to meet all the terms.
Input
The only line of input contains 4 integers N, M, K, L (1 ≤ K ≤ N ≤ 10^{18}; 1 ≤ M, L ≤ 10^{18}) — quantity of different coins, number of Ivan's friends, size of Ivan's collection and quantity of coins, that must be new in Ivan's collection.
Output
Print one number — minimal number of coins one friend can gift to satisfy all the conditions. If it is impossible to satisfy all three conditions print "-1" (without quotes).
Examples
Input
20 15 2 3
Output
1
Input
10 11 2 4
Output
-1
Note
In the first test, one coin from each friend is enough, as he will be presented with 15 different coins and 13 of them will definitely be new.
In the second test, Ivan has 11 friends, but there are only 10 different coins. So all friends can't present him different coins.
Tags: math
Correct Solution:
```
# -*- coding: utf-8 -*-
import math
def problem(in1):
inputs = list(map(int, in1.split()))
coins = inputs[0]
friends = inputs[1]
ivans_coins = inputs[2]
must_be_new = inputs[3]
gift_coins = ivans_coins + must_be_new
each = gift_coins // friends
if (gift_coins % friends > 0):
each += 1
if (friends * each > coins):
return -1
return each
if __name__ == '__main__':
in1 = input()
result = problem(in1)
print(result)
```
| 95,296 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ivan is collecting coins. There are only N different collectible coins, Ivan has K of them. He will be celebrating his birthday soon, so all his M freinds decided to gift him coins. They all agreed to three terms:
* Everyone must gift as many coins as others.
* All coins given to Ivan must be different.
* Not less than L coins from gifts altogether, must be new in Ivan's collection.
But his friends don't know which coins have Ivan already got in his collection. They don't want to spend money so they want to buy minimum quantity of coins, that satisfy all terms, irrespective of the Ivan's collection. Help them to find this minimum number of coins or define it's not possible to meet all the terms.
Input
The only line of input contains 4 integers N, M, K, L (1 ≤ K ≤ N ≤ 10^{18}; 1 ≤ M, L ≤ 10^{18}) — quantity of different coins, number of Ivan's friends, size of Ivan's collection and quantity of coins, that must be new in Ivan's collection.
Output
Print one number — minimal number of coins one friend can gift to satisfy all the conditions. If it is impossible to satisfy all three conditions print "-1" (without quotes).
Examples
Input
20 15 2 3
Output
1
Input
10 11 2 4
Output
-1
Note
In the first test, one coin from each friend is enough, as he will be presented with 15 different coins and 13 of them will definitely be new.
In the second test, Ivan has 11 friends, but there are only 10 different coins. So all friends can't present him different coins.
Tags: math
Correct Solution:
```
N, M, K, L = map(int, input().split())
ans = (L + K) // M + (0 if (L + K) % M == 0 else 1)
print(ans if M * ans <= N else -1)
```
| 95,297 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ivan is collecting coins. There are only N different collectible coins, Ivan has K of them. He will be celebrating his birthday soon, so all his M freinds decided to gift him coins. They all agreed to three terms:
* Everyone must gift as many coins as others.
* All coins given to Ivan must be different.
* Not less than L coins from gifts altogether, must be new in Ivan's collection.
But his friends don't know which coins have Ivan already got in his collection. They don't want to spend money so they want to buy minimum quantity of coins, that satisfy all terms, irrespective of the Ivan's collection. Help them to find this minimum number of coins or define it's not possible to meet all the terms.
Input
The only line of input contains 4 integers N, M, K, L (1 ≤ K ≤ N ≤ 10^{18}; 1 ≤ M, L ≤ 10^{18}) — quantity of different coins, number of Ivan's friends, size of Ivan's collection and quantity of coins, that must be new in Ivan's collection.
Output
Print one number — minimal number of coins one friend can gift to satisfy all the conditions. If it is impossible to satisfy all three conditions print "-1" (without quotes).
Examples
Input
20 15 2 3
Output
1
Input
10 11 2 4
Output
-1
Note
In the first test, one coin from each friend is enough, as he will be presented with 15 different coins and 13 of them will definitely be new.
In the second test, Ivan has 11 friends, but there are only 10 different coins. So all friends can't present him different coins.
Submitted Solution:
```
n,m,k,l=map(int,input().split())
if m>n:print(-1)
else:
div,mod=(k+l)//m,(k+l)%m
if mod>0:div+=1
if m*div>n:print(-1)
else:print(div)
```
Yes
| 95,298 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ivan is collecting coins. There are only N different collectible coins, Ivan has K of them. He will be celebrating his birthday soon, so all his M freinds decided to gift him coins. They all agreed to three terms:
* Everyone must gift as many coins as others.
* All coins given to Ivan must be different.
* Not less than L coins from gifts altogether, must be new in Ivan's collection.
But his friends don't know which coins have Ivan already got in his collection. They don't want to spend money so they want to buy minimum quantity of coins, that satisfy all terms, irrespective of the Ivan's collection. Help them to find this minimum number of coins or define it's not possible to meet all the terms.
Input
The only line of input contains 4 integers N, M, K, L (1 ≤ K ≤ N ≤ 10^{18}; 1 ≤ M, L ≤ 10^{18}) — quantity of different coins, number of Ivan's friends, size of Ivan's collection and quantity of coins, that must be new in Ivan's collection.
Output
Print one number — minimal number of coins one friend can gift to satisfy all the conditions. If it is impossible to satisfy all three conditions print "-1" (without quotes).
Examples
Input
20 15 2 3
Output
1
Input
10 11 2 4
Output
-1
Note
In the first test, one coin from each friend is enough, as he will be presented with 15 different coins and 13 of them will definitely be new.
In the second test, Ivan has 11 friends, but there are only 10 different coins. So all friends can't present him different coins.
Submitted Solution:
```
n, m, k, l = list(map(int, input().split()))
target = l + k
perfriend = target // m + (1 if target % m else 0)
if perfriend * m > n or m > n or target > n:
print(-1)
else:
print(perfriend)
```
Yes
| 95,299 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.