text stringlengths 216 39.6k | conversation_id int64 219 108k | embedding list | cluster int64 11 11 |
|---|---|---|---|
Provide a correct Python 3 solution for this coding contest problem.
Decades have passed since the beginning of AtCoder Beginner Contest.
The contests are labeled as `ABC001`, `ABC002`, ... from the first round, but after the 999-th round `ABC999`, a problem occurred: how the future rounds should be labeled?
In the end, the labels for the rounds from the 1000-th to the 1998-th are decided: `ABD001`, `ABD002`, ..., `ABD999`.
You are given an integer N between 1 and 1998 (inclusive). Print the first three characters of the label of the N-th round of AtCoder Beginner Contest.
Constraints
* 1 \leq N \leq 1998
* N is an integer.
Input
Input is given from Standard Input in the following format:
N
Output
Print the first three characters of the label of the N-th round of AtCoder Beginner Contest.
Examples
Input
999
Output
ABC
Input
1000
Output
ABD
Input
1481
Output
ABD
"Correct Solution:
```
print("ABC" if len(input())<=3 else "ABD")
```
| 48,624 | [
0.515625,
-0.217529296875,
-0.396484375,
0.061309814453125,
-0.404296875,
-0.55859375,
0.01303863525390625,
0.1688232421875,
0.138916015625,
0.37744140625,
0.69580078125,
-0.486328125,
-0.045074462890625,
-0.8759765625,
-0.2470703125,
0.321044921875,
-0.425537109375,
-0.76904296875... | 11 |
Provide a correct Python 3 solution for this coding contest problem.
Decades have passed since the beginning of AtCoder Beginner Contest.
The contests are labeled as `ABC001`, `ABC002`, ... from the first round, but after the 999-th round `ABC999`, a problem occurred: how the future rounds should be labeled?
In the end, the labels for the rounds from the 1000-th to the 1998-th are decided: `ABD001`, `ABD002`, ..., `ABD999`.
You are given an integer N between 1 and 1998 (inclusive). Print the first three characters of the label of the N-th round of AtCoder Beginner Contest.
Constraints
* 1 \leq N \leq 1998
* N is an integer.
Input
Input is given from Standard Input in the following format:
N
Output
Print the first three characters of the label of the N-th round of AtCoder Beginner Contest.
Examples
Input
999
Output
ABC
Input
1000
Output
ABD
Input
1481
Output
ABD
"Correct Solution:
```
print("ABC" if len(input().rstrip()) <= 3 else "ABD")
```
| 48,625 | [
0.53369140625,
-0.2083740234375,
-0.370361328125,
0.0689697265625,
-0.4052734375,
-0.55029296875,
-0.021087646484375,
0.13232421875,
0.1400146484375,
0.389404296875,
0.716796875,
-0.533203125,
-0.0521240234375,
-0.86328125,
-0.2076416015625,
0.346435546875,
-0.44677734375,
-0.77294... | 11 |
Provide a correct Python 3 solution for this coding contest problem.
Decades have passed since the beginning of AtCoder Beginner Contest.
The contests are labeled as `ABC001`, `ABC002`, ... from the first round, but after the 999-th round `ABC999`, a problem occurred: how the future rounds should be labeled?
In the end, the labels for the rounds from the 1000-th to the 1998-th are decided: `ABD001`, `ABD002`, ..., `ABD999`.
You are given an integer N between 1 and 1998 (inclusive). Print the first three characters of the label of the N-th round of AtCoder Beginner Contest.
Constraints
* 1 \leq N \leq 1998
* N is an integer.
Input
Input is given from Standard Input in the following format:
N
Output
Print the first three characters of the label of the N-th round of AtCoder Beginner Contest.
Examples
Input
999
Output
ABC
Input
1000
Output
ABD
Input
1481
Output
ABD
"Correct Solution:
```
s=int(input())
if(s>=1000):
print('ABD')
else:
print('ABC')
```
| 48,626 | [
0.50830078125,
-0.2337646484375,
-0.43798828125,
0.0970458984375,
-0.400634765625,
-0.55224609375,
-0.016448974609375,
0.164794921875,
0.135009765625,
0.350830078125,
0.689453125,
-0.450927734375,
-0.09033203125,
-0.8505859375,
-0.207763671875,
0.2890625,
-0.446533203125,
-0.752929... | 11 |
Provide a correct Python 3 solution for this coding contest problem.
Decades have passed since the beginning of AtCoder Beginner Contest.
The contests are labeled as `ABC001`, `ABC002`, ... from the first round, but after the 999-th round `ABC999`, a problem occurred: how the future rounds should be labeled?
In the end, the labels for the rounds from the 1000-th to the 1998-th are decided: `ABD001`, `ABD002`, ..., `ABD999`.
You are given an integer N between 1 and 1998 (inclusive). Print the first three characters of the label of the N-th round of AtCoder Beginner Contest.
Constraints
* 1 \leq N \leq 1998
* N is an integer.
Input
Input is given from Standard Input in the following format:
N
Output
Print the first three characters of the label of the N-th round of AtCoder Beginner Contest.
Examples
Input
999
Output
ABC
Input
1000
Output
ABD
Input
1481
Output
ABD
"Correct Solution:
```
s = input()
print("ABC" if len(s)<=3 else "ABD")
```
| 48,627 | [
0.5009765625,
-0.212158203125,
-0.384033203125,
0.04461669921875,
-0.42333984375,
-0.5380859375,
-0.019866943359375,
0.187255859375,
0.1307373046875,
0.36865234375,
0.69482421875,
-0.49169921875,
-0.04345703125,
-0.87939453125,
-0.253662109375,
0.28759765625,
-0.434814453125,
-0.75... | 11 |
Provide a correct Python 3 solution for this coding contest problem.
Decades have passed since the beginning of AtCoder Beginner Contest.
The contests are labeled as `ABC001`, `ABC002`, ... from the first round, but after the 999-th round `ABC999`, a problem occurred: how the future rounds should be labeled?
In the end, the labels for the rounds from the 1000-th to the 1998-th are decided: `ABD001`, `ABD002`, ..., `ABD999`.
You are given an integer N between 1 and 1998 (inclusive). Print the first three characters of the label of the N-th round of AtCoder Beginner Contest.
Constraints
* 1 \leq N \leq 1998
* N is an integer.
Input
Input is given from Standard Input in the following format:
N
Output
Print the first three characters of the label of the N-th round of AtCoder Beginner Contest.
Examples
Input
999
Output
ABC
Input
1000
Output
ABD
Input
1481
Output
ABD
"Correct Solution:
```
n = int(input())
print('ABC' if 1 <= n < 1000 else 'ABD')
```
| 48,628 | [
0.50830078125,
-0.2266845703125,
-0.445068359375,
0.10833740234375,
-0.404541015625,
-0.58642578125,
-0.04541015625,
0.1673583984375,
0.138916015625,
0.38232421875,
0.70068359375,
-0.446533203125,
-0.09710693359375,
-0.86279296875,
-0.20458984375,
0.276123046875,
-0.461181640625,
-... | 11 |
Provide a correct Python 3 solution for this coding contest problem.
Decades have passed since the beginning of AtCoder Beginner Contest.
The contests are labeled as `ABC001`, `ABC002`, ... from the first round, but after the 999-th round `ABC999`, a problem occurred: how the future rounds should be labeled?
In the end, the labels for the rounds from the 1000-th to the 1998-th are decided: `ABD001`, `ABD002`, ..., `ABD999`.
You are given an integer N between 1 and 1998 (inclusive). Print the first three characters of the label of the N-th round of AtCoder Beginner Contest.
Constraints
* 1 \leq N \leq 1998
* N is an integer.
Input
Input is given from Standard Input in the following format:
N
Output
Print the first three characters of the label of the N-th round of AtCoder Beginner Contest.
Examples
Input
999
Output
ABC
Input
1000
Output
ABD
Input
1481
Output
ABD
"Correct Solution:
```
print("ABC" if (int(input())<1000) else "ABD")
```
| 48,629 | [
0.50048828125,
-0.2100830078125,
-0.4345703125,
0.096435546875,
-0.3857421875,
-0.57958984375,
-0.0264739990234375,
0.1983642578125,
0.14306640625,
0.358154296875,
0.68212890625,
-0.45703125,
-0.06390380859375,
-0.86962890625,
-0.2022705078125,
0.312255859375,
-0.46240234375,
-0.75... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Decades have passed since the beginning of AtCoder Beginner Contest.
The contests are labeled as `ABC001`, `ABC002`, ... from the first round, but after the 999-th round `ABC999`, a problem occurred: how the future rounds should be labeled?
In the end, the labels for the rounds from the 1000-th to the 1998-th are decided: `ABD001`, `ABD002`, ..., `ABD999`.
You are given an integer N between 1 and 1998 (inclusive). Print the first three characters of the label of the N-th round of AtCoder Beginner Contest.
Constraints
* 1 \leq N \leq 1998
* N is an integer.
Input
Input is given from Standard Input in the following format:
N
Output
Print the first three characters of the label of the N-th round of AtCoder Beginner Contest.
Examples
Input
999
Output
ABC
Input
1000
Output
ABD
Input
1481
Output
ABD
Submitted Solution:
```
n=int(input())
print('ABC' if n<1000 else 'ABD')
```
Yes
| 48,630 | [
0.5693359375,
-0.208740234375,
-0.354736328125,
0.02923583984375,
-0.398193359375,
-0.54736328125,
-0.1129150390625,
0.2083740234375,
0.160888671875,
0.36767578125,
0.58740234375,
-0.479248046875,
-0.0965576171875,
-0.78466796875,
-0.1748046875,
0.189208984375,
-0.40576171875,
-0.7... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Decades have passed since the beginning of AtCoder Beginner Contest.
The contests are labeled as `ABC001`, `ABC002`, ... from the first round, but after the 999-th round `ABC999`, a problem occurred: how the future rounds should be labeled?
In the end, the labels for the rounds from the 1000-th to the 1998-th are decided: `ABD001`, `ABD002`, ..., `ABD999`.
You are given an integer N between 1 and 1998 (inclusive). Print the first three characters of the label of the N-th round of AtCoder Beginner Contest.
Constraints
* 1 \leq N \leq 1998
* N is an integer.
Input
Input is given from Standard Input in the following format:
N
Output
Print the first three characters of the label of the N-th round of AtCoder Beginner Contest.
Examples
Input
999
Output
ABC
Input
1000
Output
ABD
Input
1481
Output
ABD
Submitted Solution:
```
print("AB" + ("C" if int(input()) <= 999 else "D"))
```
Yes
| 48,631 | [
0.5693359375,
-0.1783447265625,
-0.323974609375,
0.02984619140625,
-0.407958984375,
-0.537109375,
-0.08251953125,
0.203857421875,
0.1378173828125,
0.3515625,
0.5537109375,
-0.467529296875,
-0.091064453125,
-0.8076171875,
-0.1876220703125,
0.192626953125,
-0.394775390625,
-0.7290039... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Decades have passed since the beginning of AtCoder Beginner Contest.
The contests are labeled as `ABC001`, `ABC002`, ... from the first round, but after the 999-th round `ABC999`, a problem occurred: how the future rounds should be labeled?
In the end, the labels for the rounds from the 1000-th to the 1998-th are decided: `ABD001`, `ABD002`, ..., `ABD999`.
You are given an integer N between 1 and 1998 (inclusive). Print the first three characters of the label of the N-th round of AtCoder Beginner Contest.
Constraints
* 1 \leq N \leq 1998
* N is an integer.
Input
Input is given from Standard Input in the following format:
N
Output
Print the first three characters of the label of the N-th round of AtCoder Beginner Contest.
Examples
Input
999
Output
ABC
Input
1000
Output
ABD
Input
1481
Output
ABD
Submitted Solution:
```
N = int(input())
print("ABC" if N < 1000 else "ABD")
```
Yes
| 48,632 | [
0.5693359375,
-0.196044921875,
-0.360595703125,
0.032257080078125,
-0.40283203125,
-0.5546875,
-0.113525390625,
0.2149658203125,
0.155517578125,
0.36572265625,
0.5908203125,
-0.47705078125,
-0.103515625,
-0.78564453125,
-0.1763916015625,
0.2001953125,
-0.406982421875,
-0.755859375,... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Decades have passed since the beginning of AtCoder Beginner Contest.
The contests are labeled as `ABC001`, `ABC002`, ... from the first round, but after the 999-th round `ABC999`, a problem occurred: how the future rounds should be labeled?
In the end, the labels for the rounds from the 1000-th to the 1998-th are decided: `ABD001`, `ABD002`, ..., `ABD999`.
You are given an integer N between 1 and 1998 (inclusive). Print the first three characters of the label of the N-th round of AtCoder Beginner Contest.
Constraints
* 1 \leq N \leq 1998
* N is an integer.
Input
Input is given from Standard Input in the following format:
N
Output
Print the first three characters of the label of the N-th round of AtCoder Beginner Contest.
Examples
Input
999
Output
ABC
Input
1000
Output
ABD
Input
1481
Output
ABD
Submitted Solution:
```
n=int(input())
print("AB"+"C"*(n<1000)+"D"*(n>=1000))
```
Yes
| 48,633 | [
0.59130859375,
-0.190185546875,
-0.313232421875,
0.03692626953125,
-0.40576171875,
-0.505859375,
-0.09051513671875,
0.182373046875,
0.1424560546875,
0.373779296875,
0.56787109375,
-0.485107421875,
-0.08270263671875,
-0.7978515625,
-0.1595458984375,
0.19677734375,
-0.39794921875,
-0... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Decades have passed since the beginning of AtCoder Beginner Contest.
The contests are labeled as `ABC001`, `ABC002`, ... from the first round, but after the 999-th round `ABC999`, a problem occurred: how the future rounds should be labeled?
In the end, the labels for the rounds from the 1000-th to the 1998-th are decided: `ABD001`, `ABD002`, ..., `ABD999`.
You are given an integer N between 1 and 1998 (inclusive). Print the first three characters of the label of the N-th round of AtCoder Beginner Contest.
Constraints
* 1 \leq N \leq 1998
* N is an integer.
Input
Input is given from Standard Input in the following format:
N
Output
Print the first three characters of the label of the N-th round of AtCoder Beginner Contest.
Examples
Input
999
Output
ABC
Input
1000
Output
ABD
Input
1481
Output
ABD
Submitted Solution:
```
a = input()
b = input()
X = b - a
s = int((X*(X+1))/2 - b)
print(s)
```
No
| 48,634 | [
0.5703125,
-0.1802978515625,
-0.299072265625,
0.00453948974609375,
-0.367431640625,
-0.53369140625,
-0.159423828125,
0.167724609375,
0.135498046875,
0.372802734375,
0.59814453125,
-0.4462890625,
-0.09149169921875,
-0.78662109375,
-0.1453857421875,
0.211669921875,
-0.3564453125,
-0.... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Decades have passed since the beginning of AtCoder Beginner Contest.
The contests are labeled as `ABC001`, `ABC002`, ... from the first round, but after the 999-th round `ABC999`, a problem occurred: how the future rounds should be labeled?
In the end, the labels for the rounds from the 1000-th to the 1998-th are decided: `ABD001`, `ABD002`, ..., `ABD999`.
You are given an integer N between 1 and 1998 (inclusive). Print the first three characters of the label of the N-th round of AtCoder Beginner Contest.
Constraints
* 1 \leq N \leq 1998
* N is an integer.
Input
Input is given from Standard Input in the following format:
N
Output
Print the first three characters of the label of the N-th round of AtCoder Beginner Contest.
Examples
Input
999
Output
ABC
Input
1000
Output
ABD
Input
1481
Output
ABD
Submitted Solution:
```
n = int(input())
if n < 1000:
print("ABC%03d" % n)
else:
print("ABD%03d" % (n-1000))
```
No
| 48,635 | [
0.55908203125,
-0.188720703125,
-0.344482421875,
0.0531005859375,
-0.384521484375,
-0.53857421875,
-0.090576171875,
0.1881103515625,
0.1368408203125,
0.40771484375,
0.56982421875,
-0.47314453125,
-0.0838623046875,
-0.79638671875,
-0.169189453125,
0.2117919921875,
-0.368408203125,
-... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Decades have passed since the beginning of AtCoder Beginner Contest.
The contests are labeled as `ABC001`, `ABC002`, ... from the first round, but after the 999-th round `ABC999`, a problem occurred: how the future rounds should be labeled?
In the end, the labels for the rounds from the 1000-th to the 1998-th are decided: `ABD001`, `ABD002`, ..., `ABD999`.
You are given an integer N between 1 and 1998 (inclusive). Print the first three characters of the label of the N-th round of AtCoder Beginner Contest.
Constraints
* 1 \leq N \leq 1998
* N is an integer.
Input
Input is given from Standard Input in the following format:
N
Output
Print the first three characters of the label of the N-th round of AtCoder Beginner Contest.
Examples
Input
999
Output
ABC
Input
1000
Output
ABD
Input
1481
Output
ABD
Submitted Solution:
```
N = input()
if N > 1000 :
Npadded = '%03d' % N
print("ABC",Npadded)
else :
Npadded = '%03d' % (N - 999)
print("ABD",Npadded)
```
No
| 48,636 | [
0.501953125,
-0.2034912109375,
-0.3525390625,
-0.00986480712890625,
-0.36865234375,
-0.54541015625,
-0.072509765625,
0.172607421875,
0.1441650390625,
0.38134765625,
0.55712890625,
-0.485107421875,
-0.0501708984375,
-0.79931640625,
-0.17578125,
0.25537109375,
-0.32568359375,
-0.8012... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Decades have passed since the beginning of AtCoder Beginner Contest.
The contests are labeled as `ABC001`, `ABC002`, ... from the first round, but after the 999-th round `ABC999`, a problem occurred: how the future rounds should be labeled?
In the end, the labels for the rounds from the 1000-th to the 1998-th are decided: `ABD001`, `ABD002`, ..., `ABD999`.
You are given an integer N between 1 and 1998 (inclusive). Print the first three characters of the label of the N-th round of AtCoder Beginner Contest.
Constraints
* 1 \leq N \leq 1998
* N is an integer.
Input
Input is given from Standard Input in the following format:
N
Output
Print the first three characters of the label of the N-th round of AtCoder Beginner Contest.
Examples
Input
999
Output
ABC
Input
1000
Output
ABD
Input
1481
Output
ABD
Submitted Solution:
```
N = int(input())
if N < 1000:
print("ABC{:03d}".format(N))
else:
print("ABD{:03d}".format(N-999))
```
No
| 48,637 | [
0.54931640625,
-0.1796875,
-0.34228515625,
0.045196533203125,
-0.380859375,
-0.53173828125,
-0.068603515625,
0.173828125,
0.14501953125,
0.4267578125,
0.57666015625,
-0.490478515625,
-0.09063720703125,
-0.7802734375,
-0.1788330078125,
0.2091064453125,
-0.363525390625,
-0.7841796875... | 11 |
Provide a correct Python 3 solution for this coding contest problem.
The time is 2020. There is data that saves the qualifying results of PC Koshien 2020. This data stores the reference number and the number of correct answers assigned to each team. Here, the ranking is determined by the number of correct answers, and the ranking is given in descending order of the number of correct answers, such as 1st, 2nd, and so on.
Enter the qualifying result data and reference number from the keyboard, and create a program that outputs the ranking of the team with that number.
Note
In the data of the input example, if the teams are arranged in order of the number of correct answers:
3,30
1,20
2,20
6,20
4,10
5,10
It will be. Here, in order to determine the ranking based on the number of correct answers, the 30-question correct answer team is ranked 1st, the 20-question correct answer team is ranked 2nd, and the 10-question correct answer team is ranked 3rd. Please note that this is different from the usual ranking with the correct team in 5th place).
Input
The input data consists of two parts. The first half is the qualifying result data, and the second half is the inquiry of the team number for which you want to know the ranking. The format of the qualifying result data is as follows.
p1, s1
p2, s2
...
...
0,0
pi (1 ≤ pi ≤ 100) and si (0 ≤ si ≤ 30) are integers representing the reference number and the number of correct answers for the i-th team, respectively. It is assumed that the input of this data is completed when both the reference number and the number of correct answers are 0.
Then multiple inquiries in the second half are given. The inquiry format is as follows.
q1
q2
::
Each query is given the reference number qi (1 ≤ qi ≤ 30) on one line. Please process this until the end of the input. The number of inquiries does not exceed 100.
Output
For each inquiry, print the team ranking on one line.
Example
Input
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
Output
2
2
3
3
"Correct Solution:
```
# -*- coding: utf-8 -*-
import sys
import os
scores = [0]
for s in sys.stdin:
p, s = map(int, s.split(','))
if p == s == 0:
break
else:
scores.append(s)
score_set = set(scores)
score_set = list(score_set)
score_set.sort(reverse=True)
for s in sys.stdin:
n = int(s)
teams_score = scores[n]
print(score_set.index(teams_score) + 1)
```
| 48,706 | [
0.428466796875,
-0.01641845703125,
-0.0189056396484375,
0.06292724609375,
-0.435791015625,
-0.224365234375,
-0.1827392578125,
0.2039794921875,
0.07696533203125,
0.560546875,
0.20361328125,
0.018951416015625,
0.035797119140625,
-0.45654296875,
-0.58154296875,
-0.490966796875,
-0.41845... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The time is 2020. There is data that saves the qualifying results of PC Koshien 2020. This data stores the reference number and the number of correct answers assigned to each team. Here, the ranking is determined by the number of correct answers, and the ranking is given in descending order of the number of correct answers, such as 1st, 2nd, and so on.
Enter the qualifying result data and reference number from the keyboard, and create a program that outputs the ranking of the team with that number.
Note
In the data of the input example, if the teams are arranged in order of the number of correct answers:
3,30
1,20
2,20
6,20
4,10
5,10
It will be. Here, in order to determine the ranking based on the number of correct answers, the 30-question correct answer team is ranked 1st, the 20-question correct answer team is ranked 2nd, and the 10-question correct answer team is ranked 3rd. Please note that this is different from the usual ranking with the correct team in 5th place).
Input
The input data consists of two parts. The first half is the qualifying result data, and the second half is the inquiry of the team number for which you want to know the ranking. The format of the qualifying result data is as follows.
p1, s1
p2, s2
...
...
0,0
pi (1 ≤ pi ≤ 100) and si (0 ≤ si ≤ 30) are integers representing the reference number and the number of correct answers for the i-th team, respectively. It is assumed that the input of this data is completed when both the reference number and the number of correct answers are 0.
Then multiple inquiries in the second half are given. The inquiry format is as follows.
q1
q2
::
Each query is given the reference number qi (1 ≤ qi ≤ 30) on one line. Please process this until the end of the input. The number of inquiries does not exceed 100.
Output
For each inquiry, print the team ranking on one line.
Example
Input
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
Output
2
2
3
3
Submitted Solution:
```
t = [0] * 101
while 1:
p, s = map(int, input().split(','))
if p == s == 0:
break
t[p] = s
rank = list(set(t))
rank.sort(reverse=True)
while 1:
try:
n = int(input())
print(rank.index(t[n])+1)
except:
break
```
Yes
| 48,710 | [
0.443115234375,
-0.06475830078125,
-0.047698974609375,
0.07257080078125,
-0.458740234375,
-0.1270751953125,
-0.175537109375,
0.1968994140625,
0.04931640625,
0.587890625,
0.2432861328125,
0.0673828125,
0.0631103515625,
-0.505859375,
-0.5615234375,
-0.509765625,
-0.347412109375,
-0.7... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The time is 2020. There is data that saves the qualifying results of PC Koshien 2020. This data stores the reference number and the number of correct answers assigned to each team. Here, the ranking is determined by the number of correct answers, and the ranking is given in descending order of the number of correct answers, such as 1st, 2nd, and so on.
Enter the qualifying result data and reference number from the keyboard, and create a program that outputs the ranking of the team with that number.
Note
In the data of the input example, if the teams are arranged in order of the number of correct answers:
3,30
1,20
2,20
6,20
4,10
5,10
It will be. Here, in order to determine the ranking based on the number of correct answers, the 30-question correct answer team is ranked 1st, the 20-question correct answer team is ranked 2nd, and the 10-question correct answer team is ranked 3rd. Please note that this is different from the usual ranking with the correct team in 5th place).
Input
The input data consists of two parts. The first half is the qualifying result data, and the second half is the inquiry of the team number for which you want to know the ranking. The format of the qualifying result data is as follows.
p1, s1
p2, s2
...
...
0,0
pi (1 ≤ pi ≤ 100) and si (0 ≤ si ≤ 30) are integers representing the reference number and the number of correct answers for the i-th team, respectively. It is assumed that the input of this data is completed when both the reference number and the number of correct answers are 0.
Then multiple inquiries in the second half are given. The inquiry format is as follows.
q1
q2
::
Each query is given the reference number qi (1 ≤ qi ≤ 30) on one line. Please process this until the end of the input. The number of inquiries does not exceed 100.
Output
For each inquiry, print the team ranking on one line.
Example
Input
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
Output
2
2
3
3
Submitted Solution:
```
import sys
c,d=[],{}
for x in iter(input,'0,0'):p,s=map(int,x.split(','));c+=[s];d[p]=s
for y in sys.stdin:print(sorted({*c})[::-1].index(d[int(y)])+1)
```
Yes
| 48,711 | [
0.440673828125,
-0.110107421875,
-0.026885986328125,
0.060211181640625,
-0.463623046875,
-0.102294921875,
-0.218017578125,
0.162841796875,
0.0421142578125,
0.56689453125,
0.20263671875,
0.042205810546875,
0.0767822265625,
-0.46142578125,
-0.5810546875,
-0.50390625,
-0.344970703125,
... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The time is 2020. There is data that saves the qualifying results of PC Koshien 2020. This data stores the reference number and the number of correct answers assigned to each team. Here, the ranking is determined by the number of correct answers, and the ranking is given in descending order of the number of correct answers, such as 1st, 2nd, and so on.
Enter the qualifying result data and reference number from the keyboard, and create a program that outputs the ranking of the team with that number.
Note
In the data of the input example, if the teams are arranged in order of the number of correct answers:
3,30
1,20
2,20
6,20
4,10
5,10
It will be. Here, in order to determine the ranking based on the number of correct answers, the 30-question correct answer team is ranked 1st, the 20-question correct answer team is ranked 2nd, and the 10-question correct answer team is ranked 3rd. Please note that this is different from the usual ranking with the correct team in 5th place).
Input
The input data consists of two parts. The first half is the qualifying result data, and the second half is the inquiry of the team number for which you want to know the ranking. The format of the qualifying result data is as follows.
p1, s1
p2, s2
...
...
0,0
pi (1 ≤ pi ≤ 100) and si (0 ≤ si ≤ 30) are integers representing the reference number and the number of correct answers for the i-th team, respectively. It is assumed that the input of this data is completed when both the reference number and the number of correct answers are 0.
Then multiple inquiries in the second half are given. The inquiry format is as follows.
q1
q2
::
Each query is given the reference number qi (1 ≤ qi ≤ 30) on one line. Please process this until the end of the input. The number of inquiries does not exceed 100.
Output
For each inquiry, print the team ranking on one line.
Example
Input
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
Output
2
2
3
3
Submitted Solution:
```
import itertools
from operator import itemgetter
nums={}
while True:
p,s=map(int,input().split(','))
if(p==0 and s==0):break
if not s in nums:
nums[s]=[]
nums[s].append(p)
while True:
try:
q=int(input())
ans=len(nums)
for ns in nums.items():
if q in ns[1]:
print(ans)
break
ans-=1
except:
break
```
Yes
| 48,712 | [
0.397705078125,
-0.1337890625,
-0.171875,
0.0443115234375,
-0.451416015625,
-0.15234375,
-0.2109375,
0.1473388671875,
0.09906005859375,
0.62646484375,
0.2271728515625,
0.014617919921875,
0.0401611328125,
-0.427734375,
-0.50341796875,
-0.54296875,
-0.329833984375,
-0.75537109375,
... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The time is 2020. There is data that saves the qualifying results of PC Koshien 2020. This data stores the reference number and the number of correct answers assigned to each team. Here, the ranking is determined by the number of correct answers, and the ranking is given in descending order of the number of correct answers, such as 1st, 2nd, and so on.
Enter the qualifying result data and reference number from the keyboard, and create a program that outputs the ranking of the team with that number.
Note
In the data of the input example, if the teams are arranged in order of the number of correct answers:
3,30
1,20
2,20
6,20
4,10
5,10
It will be. Here, in order to determine the ranking based on the number of correct answers, the 30-question correct answer team is ranked 1st, the 20-question correct answer team is ranked 2nd, and the 10-question correct answer team is ranked 3rd. Please note that this is different from the usual ranking with the correct team in 5th place).
Input
The input data consists of two parts. The first half is the qualifying result data, and the second half is the inquiry of the team number for which you want to know the ranking. The format of the qualifying result data is as follows.
p1, s1
p2, s2
...
...
0,0
pi (1 ≤ pi ≤ 100) and si (0 ≤ si ≤ 30) are integers representing the reference number and the number of correct answers for the i-th team, respectively. It is assumed that the input of this data is completed when both the reference number and the number of correct answers are 0.
Then multiple inquiries in the second half are given. The inquiry format is as follows.
q1
q2
::
Each query is given the reference number qi (1 ≤ qi ≤ 30) on one line. Please process this until the end of the input. The number of inquiries does not exceed 100.
Output
For each inquiry, print the team ranking on one line.
Example
Input
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
Output
2
2
3
3
Submitted Solution:
```
c=[]
d={}
while 1:
a,b=map(int,input().split(','))
if a==0:break
c+=[b]
d[a]=b
c=sorted(set(c))[::-1]
while 1:
try:print(c.index(d[int(input())])+1)
except:break
```
Yes
| 48,713 | [
0.427490234375,
-0.0921630859375,
-0.0345458984375,
0.047607421875,
-0.45068359375,
-0.110595703125,
-0.1805419921875,
0.196533203125,
0.072998046875,
0.5830078125,
0.2568359375,
0.06573486328125,
0.05322265625,
-0.48193359375,
-0.5625,
-0.51318359375,
-0.359130859375,
-0.771484375... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The time is 2020. There is data that saves the qualifying results of PC Koshien 2020. This data stores the reference number and the number of correct answers assigned to each team. Here, the ranking is determined by the number of correct answers, and the ranking is given in descending order of the number of correct answers, such as 1st, 2nd, and so on.
Enter the qualifying result data and reference number from the keyboard, and create a program that outputs the ranking of the team with that number.
Note
In the data of the input example, if the teams are arranged in order of the number of correct answers:
3,30
1,20
2,20
6,20
4,10
5,10
It will be. Here, in order to determine the ranking based on the number of correct answers, the 30-question correct answer team is ranked 1st, the 20-question correct answer team is ranked 2nd, and the 10-question correct answer team is ranked 3rd. Please note that this is different from the usual ranking with the correct team in 5th place).
Input
The input data consists of two parts. The first half is the qualifying result data, and the second half is the inquiry of the team number for which you want to know the ranking. The format of the qualifying result data is as follows.
p1, s1
p2, s2
...
...
0,0
pi (1 ≤ pi ≤ 100) and si (0 ≤ si ≤ 30) are integers representing the reference number and the number of correct answers for the i-th team, respectively. It is assumed that the input of this data is completed when both the reference number and the number of correct answers are 0.
Then multiple inquiries in the second half are given. The inquiry format is as follows.
q1
q2
::
Each query is given the reference number qi (1 ≤ qi ≤ 30) on one line. Please process this until the end of the input. The number of inquiries does not exceed 100.
Output
For each inquiry, print the team ranking on one line.
Example
Input
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
Output
2
2
3
3
Submitted Solution:
```
team_score=[]
while True:
x,y=map(int,input().split(','))
if x==y==0:
break
team_score.append((x,y))
team_score.sort(key=lambda x:x[1],reverse=True)
for i,j in team_score:
print(i)
```
No
| 48,714 | [
0.446044921875,
-0.058197021484375,
-0.04010009765625,
0.1083984375,
-0.435302734375,
-0.12744140625,
-0.1690673828125,
0.1866455078125,
0.067626953125,
0.541015625,
0.2459716796875,
0.08013916015625,
0.08953857421875,
-0.492919921875,
-0.58935546875,
-0.51904296875,
-0.36376953125,
... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The time is 2020. There is data that saves the qualifying results of PC Koshien 2020. This data stores the reference number and the number of correct answers assigned to each team. Here, the ranking is determined by the number of correct answers, and the ranking is given in descending order of the number of correct answers, such as 1st, 2nd, and so on.
Enter the qualifying result data and reference number from the keyboard, and create a program that outputs the ranking of the team with that number.
Note
In the data of the input example, if the teams are arranged in order of the number of correct answers:
3,30
1,20
2,20
6,20
4,10
5,10
It will be. Here, in order to determine the ranking based on the number of correct answers, the 30-question correct answer team is ranked 1st, the 20-question correct answer team is ranked 2nd, and the 10-question correct answer team is ranked 3rd. Please note that this is different from the usual ranking with the correct team in 5th place).
Input
The input data consists of two parts. The first half is the qualifying result data, and the second half is the inquiry of the team number for which you want to know the ranking. The format of the qualifying result data is as follows.
p1, s1
p2, s2
...
...
0,0
pi (1 ≤ pi ≤ 100) and si (0 ≤ si ≤ 30) are integers representing the reference number and the number of correct answers for the i-th team, respectively. It is assumed that the input of this data is completed when both the reference number and the number of correct answers are 0.
Then multiple inquiries in the second half are given. The inquiry format is as follows.
q1
q2
::
Each query is given the reference number qi (1 ≤ qi ≤ 30) on one line. Please process this until the end of the input. The number of inquiries does not exceed 100.
Output
For each inquiry, print the team ranking on one line.
Example
Input
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
Output
2
2
3
3
Submitted Solution:
```
# -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0061
"""
import sys
def calc_rank(data):
scores = {} # ?????????key, ???????????????id???????????????value??¨?????????????????????
for id, point in data:
if point in scores:
scores[point].append(id)
else:
scores[point] = [id]
ranks = [k for k in scores.keys()] # ranks.index(point) ?????????????????????????????????
ranks.sort(reverse=True)
ranks.insert(0, 0) # index???1?????????????????????????????????????????????????????\
return scores, ranks
def check_rank(scores, ranks, id):
for k, v in scores.items():
if id in v:
return ranks.index(k)
def main(args):
data = []
id, point = [int(x) for x in input().strip().split(',')]
while id != 0 or point != 0:
data.append((id, point))
id, point = [int(x) for x in input().strip().split(',')]
scores, ranks = calc_rank(data)
for line in sys.stdin:
id = int(line.strip())
result = check_rank(scores, ranks, id)
print(result)
if __name__ == '__main__':
main(sys.argv[1:])
```
No
| 48,715 | [
0.435302734375,
-0.0762939453125,
-0.0885009765625,
0.12432861328125,
-0.489501953125,
-0.14794921875,
-0.13232421875,
0.207763671875,
0.068359375,
0.54833984375,
0.261474609375,
0.101806640625,
0.02996826171875,
-0.50537109375,
-0.56201171875,
-0.515625,
-0.327392578125,
-0.758300... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The time is 2020. There is data that saves the qualifying results of PC Koshien 2020. This data stores the reference number and the number of correct answers assigned to each team. Here, the ranking is determined by the number of correct answers, and the ranking is given in descending order of the number of correct answers, such as 1st, 2nd, and so on.
Enter the qualifying result data and reference number from the keyboard, and create a program that outputs the ranking of the team with that number.
Note
In the data of the input example, if the teams are arranged in order of the number of correct answers:
3,30
1,20
2,20
6,20
4,10
5,10
It will be. Here, in order to determine the ranking based on the number of correct answers, the 30-question correct answer team is ranked 1st, the 20-question correct answer team is ranked 2nd, and the 10-question correct answer team is ranked 3rd. Please note that this is different from the usual ranking with the correct team in 5th place).
Input
The input data consists of two parts. The first half is the qualifying result data, and the second half is the inquiry of the team number for which you want to know the ranking. The format of the qualifying result data is as follows.
p1, s1
p2, s2
...
...
0,0
pi (1 ≤ pi ≤ 100) and si (0 ≤ si ≤ 30) are integers representing the reference number and the number of correct answers for the i-th team, respectively. It is assumed that the input of this data is completed when both the reference number and the number of correct answers are 0.
Then multiple inquiries in the second half are given. The inquiry format is as follows.
q1
q2
::
Each query is given the reference number qi (1 ≤ qi ≤ 30) on one line. Please process this until the end of the input. The number of inquiries does not exceed 100.
Output
For each inquiry, print the team ranking on one line.
Example
Input
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
Output
2
2
3
3
Submitted Solution:
```
import sys
c,d=[],{}
for x in iter(input,'0,0'):p,s=map(int,x.split(','));c+=[s];d[p]=s
for y in sys.stdin:print({*c}.sort()[::-1].index(d[int(y)])+1)
```
No
| 48,716 | [
0.440673828125,
-0.110107421875,
-0.026885986328125,
0.060211181640625,
-0.463623046875,
-0.102294921875,
-0.218017578125,
0.162841796875,
0.0421142578125,
0.56689453125,
0.20263671875,
0.042205810546875,
0.0767822265625,
-0.46142578125,
-0.5810546875,
-0.50390625,
-0.344970703125,
... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The time is 2020. There is data that saves the qualifying results of PC Koshien 2020. This data stores the reference number and the number of correct answers assigned to each team. Here, the ranking is determined by the number of correct answers, and the ranking is given in descending order of the number of correct answers, such as 1st, 2nd, and so on.
Enter the qualifying result data and reference number from the keyboard, and create a program that outputs the ranking of the team with that number.
Note
In the data of the input example, if the teams are arranged in order of the number of correct answers:
3,30
1,20
2,20
6,20
4,10
5,10
It will be. Here, in order to determine the ranking based on the number of correct answers, the 30-question correct answer team is ranked 1st, the 20-question correct answer team is ranked 2nd, and the 10-question correct answer team is ranked 3rd. Please note that this is different from the usual ranking with the correct team in 5th place).
Input
The input data consists of two parts. The first half is the qualifying result data, and the second half is the inquiry of the team number for which you want to know the ranking. The format of the qualifying result data is as follows.
p1, s1
p2, s2
...
...
0,0
pi (1 ≤ pi ≤ 100) and si (0 ≤ si ≤ 30) are integers representing the reference number and the number of correct answers for the i-th team, respectively. It is assumed that the input of this data is completed when both the reference number and the number of correct answers are 0.
Then multiple inquiries in the second half are given. The inquiry format is as follows.
q1
q2
::
Each query is given the reference number qi (1 ≤ qi ≤ 30) on one line. Please process this until the end of the input. The number of inquiries does not exceed 100.
Output
For each inquiry, print the team ranking on one line.
Example
Input
1,20
2,20
3,30
4,10
5,10
6,20
0,0
1
2
4
5
Output
2
2
3
3
Submitted Solution:
```
def Inquiry(team):
ranking=1
score=team_score[0][1]
for i in team_score:
if score>i[1]:
ranking+=1
score=i[1]
if i[0]==team:
return ranking
team_score=[]
while True:
x,y=map(int,input().split(','))
if x==y==0:
break
team_score.append((x,y))
print(team_score)
team_score.sort(key=lambda x:x[1],reverse=True)
print(team_score)
while True:
try:
team=int(input())
print(Inquiry(team))
except EOFError:
break
```
No
| 48,717 | [
0.427490234375,
-0.09228515625,
-0.079345703125,
0.1097412109375,
-0.43212890625,
-0.08392333984375,
-0.183837890625,
0.1982421875,
0.09112548828125,
0.564453125,
0.230712890625,
0.042022705078125,
0.07366943359375,
-0.457275390625,
-0.5849609375,
-0.496826171875,
-0.35009765625,
-... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nauuo is a girl who loves coding.
One day she was solving a problem which requires to calculate a sum of some numbers modulo p.
She wrote the following code and got the verdict "Wrong answer".
<image>
She soon discovered the bug — the ModAdd function only worked for numbers in the range [0,p), but the numbers in the problem may be out of the range. She was curious about the wrong function, so she wanted to know the result of it.
However, the original code worked too slow, so she asked you to help her.
You are given an array a_1,a_2,…,a_n and a number p. Nauuo will make m queries, in each query, you are given l and r, and you have to calculate the results of Sum(a,l,r,p). You can see the definition of the Sum function in the pseudocode above.
Note that the integers won't overflow in the code above.
Input
The first line contains three integers n, m, p (1 ≤ n ≤ 10^6, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ p ≤ 10^9) — the length of the given array, the number of queries and the modulus. Note that the modulus is used only in the ModAdd function.
The second line contains n integers a_1,a_2,…,a_n (-10^9≤ a_i≤10^9) — the given array.
In the following m lines, each line contains two integers l, r (1≤ l≤ r≤ n) — you have to calculate the result of Sum(a,l,r,p).
Output
The output contains m integers to answer the queries in the given order.
Example
Input
4 5 6
7 2 -3 17
2 3
1 3
1 2
2 4
4 4
Output
-1
0
3
10
11
Submitted Solution:
```
n, m, p=[int(n) for n in input().split()]
l=list(map(int,input().split()))
for i in range(m):
a, b=[int(a) for a in input().split()]
k=sum(l[a-1:b])
if(k>=p):
print(k-p)
else:
print(k)
```
No
| 48,905 | [
0.337890625,
-0.151611328125,
-0.21923828125,
0.0216827392578125,
-0.7509765625,
-0.3837890625,
0.1287841796875,
0.39892578125,
0.32861328125,
0.9677734375,
0.3896484375,
-0.045745849609375,
0.1783447265625,
-0.42626953125,
-0.4697265625,
0.437744140625,
-0.296630859375,
-0.9008789... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nauuo is a girl who loves coding.
One day she was solving a problem which requires to calculate a sum of some numbers modulo p.
She wrote the following code and got the verdict "Wrong answer".
<image>
She soon discovered the bug — the ModAdd function only worked for numbers in the range [0,p), but the numbers in the problem may be out of the range. She was curious about the wrong function, so she wanted to know the result of it.
However, the original code worked too slow, so she asked you to help her.
You are given an array a_1,a_2,…,a_n and a number p. Nauuo will make m queries, in each query, you are given l and r, and you have to calculate the results of Sum(a,l,r,p). You can see the definition of the Sum function in the pseudocode above.
Note that the integers won't overflow in the code above.
Input
The first line contains three integers n, m, p (1 ≤ n ≤ 10^6, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ p ≤ 10^9) — the length of the given array, the number of queries and the modulus. Note that the modulus is used only in the ModAdd function.
The second line contains n integers a_1,a_2,…,a_n (-10^9≤ a_i≤10^9) — the given array.
In the following m lines, each line contains two integers l, r (1≤ l≤ r≤ n) — you have to calculate the result of Sum(a,l,r,p).
Output
The output contains m integers to answer the queries in the given order.
Example
Input
4 5 6
7 2 -3 17
2 3
1 3
1 2
2 4
4 4
Output
-1
0
3
10
11
Submitted Solution:
```
n, m, p=[int(n) for n in input().split()]
l=list(map(int,input().split()))
for i in range(m):
a, b=[int(a) for a in input().split()]
k=sum(l[a-1:b])
if(k>p):
print(k-p)
else:
print(k)
```
No
| 48,906 | [
0.337890625,
-0.151611328125,
-0.21923828125,
0.0216827392578125,
-0.7509765625,
-0.3837890625,
0.1287841796875,
0.39892578125,
0.32861328125,
0.9677734375,
0.3896484375,
-0.045745849609375,
0.1783447265625,
-0.42626953125,
-0.4697265625,
0.437744140625,
-0.296630859375,
-0.9008789... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is data that records the altitude of mountains that have been climbed so far. Create a program that reads this data and outputs the elevation difference between the highest and lowest mountains.
Input
The input is given in the following format:
Mountain height
...
...
The height of the mountain is given over multiple lines. All values entered are real numbers greater than or equal to 0 and less than or equal to 1,000,000. The number of mountain heights entered is 50 or less.
Output
The elevation difference between the highest mountain and the lowest mountain is output as a real number. The output may contain an error of 0.01 or less.
Example
Input
3776.0
1819.0
645.2
2004.1
1208.6
Output
3130.8
Submitted Solution:
```
list=[]
while True:
try:
mt=float(input())
except:
small=min(list)
big=max(list)
print(big-small)
break
list.append(mt)
```
Yes
| 49,521 | [
0.285400390625,
0.1483154296875,
-0.1380615234375,
0.222412109375,
-0.58349609375,
-0.156005859375,
0.131103515625,
0.2841796875,
0.1873779296875,
1.0830078125,
0.541015625,
0.265869140625,
0.1143798828125,
-1.1328125,
-0.363525390625,
-0.471435546875,
-0.75048828125,
-0.8237304687... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is data that records the altitude of mountains that have been climbed so far. Create a program that reads this data and outputs the elevation difference between the highest and lowest mountains.
Input
The input is given in the following format:
Mountain height
...
...
The height of the mountain is given over multiple lines. All values entered are real numbers greater than or equal to 0 and less than or equal to 1,000,000. The number of mountain heights entered is 50 or less.
Output
The elevation difference between the highest mountain and the lowest mountain is output as a real number. The output may contain an error of 0.01 or less.
Example
Input
3776.0
1819.0
645.2
2004.1
1208.6
Output
3130.8
Submitted Solution:
```
import sys
ms = []
for v in sys.stdin:
ms.append(float(v))
print(max(ms)-min(ms))
```
Yes
| 49,522 | [
0.226318359375,
0.1414794921875,
-0.0272064208984375,
0.239013671875,
-0.5849609375,
-0.0843505859375,
0.0318603515625,
0.318115234375,
0.05499267578125,
1.03125,
0.486083984375,
0.160400390625,
0.08294677734375,
-1.025390625,
-0.451416015625,
-0.5439453125,
-0.70849609375,
-0.8203... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is data that records the altitude of mountains that have been climbed so far. Create a program that reads this data and outputs the elevation difference between the highest and lowest mountains.
Input
The input is given in the following format:
Mountain height
...
...
The height of the mountain is given over multiple lines. All values entered are real numbers greater than or equal to 0 and less than or equal to 1,000,000. The number of mountain heights entered is 50 or less.
Output
The elevation difference between the highest mountain and the lowest mountain is output as a real number. The output may contain an error of 0.01 or less.
Example
Input
3776.0
1819.0
645.2
2004.1
1208.6
Output
3130.8
Submitted Solution:
```
a = []
while True:
try:
n = float(input())
a.append(n)
except:
break
a.sort()
print(a[len(a) - 1] - a[0])
```
Yes
| 49,523 | [
0.266845703125,
0.141845703125,
-0.1796875,
0.185302734375,
-0.57470703125,
-0.08203125,
0.1448974609375,
0.3212890625,
0.1539306640625,
1.0810546875,
0.54833984375,
0.140380859375,
0.1370849609375,
-1.1279296875,
-0.370849609375,
-0.580078125,
-0.7294921875,
-0.8193359375,
-0.18... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is data that records the altitude of mountains that have been climbed so far. Create a program that reads this data and outputs the elevation difference between the highest and lowest mountains.
Input
The input is given in the following format:
Mountain height
...
...
The height of the mountain is given over multiple lines. All values entered are real numbers greater than or equal to 0 and less than or equal to 1,000,000. The number of mountain heights entered is 50 or less.
Output
The elevation difference between the highest mountain and the lowest mountain is output as a real number. The output may contain an error of 0.01 or less.
Example
Input
3776.0
1819.0
645.2
2004.1
1208.6
Output
3130.8
Submitted Solution:
```
import sys
a=[float(e)for e in sys.stdin]
print(max(a)-min(a))
```
Yes
| 49,524 | [
0.2232666015625,
0.181884765625,
-0.087158203125,
0.244140625,
-0.59521484375,
-0.10235595703125,
0.026702880859375,
0.343017578125,
0.10418701171875,
1.0458984375,
0.453857421875,
0.1756591796875,
0.119140625,
-1.056640625,
-0.469482421875,
-0.5546875,
-0.7001953125,
-0.765625,
... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is data that records the altitude of mountains that have been climbed so far. Create a program that reads this data and outputs the elevation difference between the highest and lowest mountains.
Input
The input is given in the following format:
Mountain height
...
...
The height of the mountain is given over multiple lines. All values entered are real numbers greater than or equal to 0 and less than or equal to 1,000,000. The number of mountain heights entered is 50 or less.
Output
The elevation difference between the highest mountain and the lowest mountain is output as a real number. The output may contain an error of 0.01 or less.
Example
Input
3776.0
1819.0
645.2
2004.1
1208.6
Output
3130.8
Submitted Solution:
```
A=[]
for i in range(0,5):
a=float(input())
A.append(a)
print(max(A)-min(A))
```
No
| 49,525 | [
0.244873046875,
0.1510009765625,
-0.10443115234375,
0.2398681640625,
-0.58642578125,
-0.10467529296875,
0.1826171875,
0.288818359375,
0.1236572265625,
1.02734375,
0.59912109375,
0.07916259765625,
0.073486328125,
-1.1015625,
-0.40869140625,
-0.572265625,
-0.79296875,
-0.8203125,
-... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is data that records the altitude of mountains that have been climbed so far. Create a program that reads this data and outputs the elevation difference between the highest and lowest mountains.
Input
The input is given in the following format:
Mountain height
...
...
The height of the mountain is given over multiple lines. All values entered are real numbers greater than or equal to 0 and less than or equal to 1,000,000. The number of mountain heights entered is 50 or less.
Output
The elevation difference between the highest mountain and the lowest mountain is output as a real number. The output may contain an error of 0.01 or less.
Example
Input
3776.0
1819.0
645.2
2004.1
1208.6
Output
3130.8
Submitted Solution:
```
try:
while True:
lst=[]
a=list(input())
lst.append(a)
lst.sort()
print(max(lst)-min(lst))
except EOFError:
pass
```
No
| 49,526 | [
0.29638671875,
0.1309814453125,
-0.041595458984375,
0.1636962890625,
-0.5986328125,
-0.046630859375,
0.1029052734375,
0.372802734375,
0.2139892578125,
1.0263671875,
0.456787109375,
0.168212890625,
0.1568603515625,
-1.1279296875,
-0.416015625,
-0.5908203125,
-0.87548828125,
-0.72998... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is data that records the altitude of mountains that have been climbed so far. Create a program that reads this data and outputs the elevation difference between the highest and lowest mountains.
Input
The input is given in the following format:
Mountain height
...
...
The height of the mountain is given over multiple lines. All values entered are real numbers greater than or equal to 0 and less than or equal to 1,000,000. The number of mountain heights entered is 50 or less.
Output
The elevation difference between the highest mountain and the lowest mountain is output as a real number. The output may contain an error of 0.01 or less.
Example
Input
3776.0
1819.0
645.2
2004.1
1208.6
Output
3130.8
Submitted Solution:
```
inputs = [flaot(i) for i in input()]
print(max(inputs) - min(inputs))
```
No
| 49,527 | [
0.264404296875,
0.092529296875,
-0.1776123046875,
0.284912109375,
-0.5068359375,
-0.0777587890625,
0.067138671875,
0.325927734375,
0.1324462890625,
0.9853515625,
0.5498046875,
0.2183837890625,
0.1651611328125,
-1.1318359375,
-0.490234375,
-0.5146484375,
-0.7421875,
-0.78173828125,
... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is data that records the altitude of mountains that have been climbed so far. Create a program that reads this data and outputs the elevation difference between the highest and lowest mountains.
Input
The input is given in the following format:
Mountain height
...
...
The height of the mountain is given over multiple lines. All values entered are real numbers greater than or equal to 0 and less than or equal to 1,000,000. The number of mountain heights entered is 50 or less.
Output
The elevation difference between the highest mountain and the lowest mountain is output as a real number. The output may contain an error of 0.01 or less.
Example
Input
3776.0
1819.0
645.2
2004.1
1208.6
Output
3130.8
Submitted Solution:
```
import sys
ms = []
try:
for v in sys.stdin:
ms.append(float(v))
except:
print(max(ms)-min(ms))
```
No
| 49,528 | [
0.1944580078125,
0.140625,
-0.0240631103515625,
0.265380859375,
-0.56591796875,
-0.134521484375,
0.0509033203125,
0.29052734375,
0.049560546875,
1.0654296875,
0.498291015625,
0.14990234375,
0.058807373046875,
-1.0380859375,
-0.44287109375,
-0.578125,
-0.7099609375,
-0.80615234375,
... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are some websites that are accessible through several different addresses. For example, for a long time Codeforces was accessible with two hostnames codeforces.com and codeforces.ru.
You are given a list of page addresses being queried. For simplicity we consider all addresses to have the form http://<hostname>[/<path>], where:
* <hostname> — server name (consists of words and maybe some dots separating them),
* /<path> — optional part, where <path> consists of words separated by slashes.
We consider two <hostname> to correspond to one website if for each query to the first <hostname> there will be exactly the same query to the second one and vice versa — for each query to the second <hostname> there will be the same query to the first one. Take a look at the samples for further clarifications.
Your goal is to determine the groups of server names that correspond to one website. Ignore groups consisting of the only server name.
Please note, that according to the above definition queries http://<hostname> and http://<hostname>/ are different.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 100 000) — the number of page queries. Then follow n lines each containing exactly one address. Each address is of the form http://<hostname>[/<path>], where:
* <hostname> consists of lowercase English letters and dots, there are no two consecutive dots, <hostname> doesn't start or finish with a dot. The length of <hostname> is positive and doesn't exceed 20.
* <path> consists of lowercase English letters, dots and slashes. There are no two consecutive slashes, <path> doesn't start with a slash and its length doesn't exceed 20.
Addresses are not guaranteed to be distinct.
Output
First print k — the number of groups of server names that correspond to one website. You should count only groups of size greater than one.
Next k lines should contain the description of groups, one group per line. For each group print all server names separated by a single space. You are allowed to print both groups and names inside any group in arbitrary order.
Examples
Input
10
http://abacaba.ru/test
http://abacaba.ru/
http://abacaba.com
http://abacaba.com/test
http://abacaba.de/
http://abacaba.ru/test
http://abacaba.de/test
http://abacaba.com/
http://abacaba.com/t
http://abacaba.com/test
Output
1
http://abacaba.de http://abacaba.ru
Input
14
http://c
http://ccc.bbbb/aba..b
http://cba.com
http://a.c/aba..b/a
http://abc/
http://a.c/
http://ccc.bbbb
http://ab.ac.bc.aa/
http://a.a.a/
http://ccc.bbbb/
http://cba.com/
http://cba.com/aba..b
http://a.a.a/aba..b/a
http://abc/aba..b/a
Output
2
http://cba.com http://ccc.bbbb
http://a.a.a http://a.c http://abc
Submitted Solution:
```
n=int(input())
d={}; D={}; ans=[]
for _ in range(n): s=input()+'/'; t=s.find('/',7); d.setdefault(s[:t],set()).add(s[t:])
for k in d: D.setdefault(frozenset(d[k]),[]).append(k)
{ans.append(D[k]) for k in D if len(D[k])>1}
print(len(ans))
print('\n'.join(map(' '.join,ans)))
# Made By Mostafa_Khaled
```
Yes
| 50,103 | [
0.09423828125,
0.251953125,
-0.2147216796875,
0.234619140625,
-0.66015625,
-0.1405029296875,
-0.453857421875,
0.339599609375,
0.1724853515625,
0.7412109375,
0.2509765625,
0.05865478515625,
0.350830078125,
-0.53515625,
-0.845703125,
0.341064453125,
-0.490966796875,
-0.60791015625,
... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are some websites that are accessible through several different addresses. For example, for a long time Codeforces was accessible with two hostnames codeforces.com and codeforces.ru.
You are given a list of page addresses being queried. For simplicity we consider all addresses to have the form http://<hostname>[/<path>], where:
* <hostname> — server name (consists of words and maybe some dots separating them),
* /<path> — optional part, where <path> consists of words separated by slashes.
We consider two <hostname> to correspond to one website if for each query to the first <hostname> there will be exactly the same query to the second one and vice versa — for each query to the second <hostname> there will be the same query to the first one. Take a look at the samples for further clarifications.
Your goal is to determine the groups of server names that correspond to one website. Ignore groups consisting of the only server name.
Please note, that according to the above definition queries http://<hostname> and http://<hostname>/ are different.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 100 000) — the number of page queries. Then follow n lines each containing exactly one address. Each address is of the form http://<hostname>[/<path>], where:
* <hostname> consists of lowercase English letters and dots, there are no two consecutive dots, <hostname> doesn't start or finish with a dot. The length of <hostname> is positive and doesn't exceed 20.
* <path> consists of lowercase English letters, dots and slashes. There are no two consecutive slashes, <path> doesn't start with a slash and its length doesn't exceed 20.
Addresses are not guaranteed to be distinct.
Output
First print k — the number of groups of server names that correspond to one website. You should count only groups of size greater than one.
Next k lines should contain the description of groups, one group per line. For each group print all server names separated by a single space. You are allowed to print both groups and names inside any group in arbitrary order.
Examples
Input
10
http://abacaba.ru/test
http://abacaba.ru/
http://abacaba.com
http://abacaba.com/test
http://abacaba.de/
http://abacaba.ru/test
http://abacaba.de/test
http://abacaba.com/
http://abacaba.com/t
http://abacaba.com/test
Output
1
http://abacaba.de http://abacaba.ru
Input
14
http://c
http://ccc.bbbb/aba..b
http://cba.com
http://a.c/aba..b/a
http://abc/
http://a.c/
http://ccc.bbbb
http://ab.ac.bc.aa/
http://a.a.a/
http://ccc.bbbb/
http://cba.com/
http://cba.com/aba..b
http://a.a.a/aba..b/a
http://abc/aba..b/a
Output
2
http://cba.com http://ccc.bbbb
http://a.a.a http://a.c http://abc
Submitted Solution:
```
n = int(input())
hosts = dict()
for i in range(n):
inp = input()
pos = inp.find("/", 7)
if pos == -1: pos = len(inp)
hostName = inp[:pos]
path = inp[pos:]
if hostName not in hosts:
hosts[hostName] = set()
hosts[hostName].add(path)
groups = dict()
for name in hosts.keys():
paths = tuple(sorted(hosts[name]))
if paths not in groups:
groups[paths] = []
groups[paths].append(name)
ans = []
for group in groups.values():
if len(group) > 1:
ans.append(group)
print(len(ans))
for group in ans:
print(" ".join(group))
```
Yes
| 50,104 | [
0.09423828125,
0.251953125,
-0.2147216796875,
0.234619140625,
-0.66015625,
-0.1405029296875,
-0.453857421875,
0.339599609375,
0.1724853515625,
0.7412109375,
0.2509765625,
0.05865478515625,
0.350830078125,
-0.53515625,
-0.845703125,
0.341064453125,
-0.490966796875,
-0.60791015625,
... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are some websites that are accessible through several different addresses. For example, for a long time Codeforces was accessible with two hostnames codeforces.com and codeforces.ru.
You are given a list of page addresses being queried. For simplicity we consider all addresses to have the form http://<hostname>[/<path>], where:
* <hostname> — server name (consists of words and maybe some dots separating them),
* /<path> — optional part, where <path> consists of words separated by slashes.
We consider two <hostname> to correspond to one website if for each query to the first <hostname> there will be exactly the same query to the second one and vice versa — for each query to the second <hostname> there will be the same query to the first one. Take a look at the samples for further clarifications.
Your goal is to determine the groups of server names that correspond to one website. Ignore groups consisting of the only server name.
Please note, that according to the above definition queries http://<hostname> and http://<hostname>/ are different.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 100 000) — the number of page queries. Then follow n lines each containing exactly one address. Each address is of the form http://<hostname>[/<path>], where:
* <hostname> consists of lowercase English letters and dots, there are no two consecutive dots, <hostname> doesn't start or finish with a dot. The length of <hostname> is positive and doesn't exceed 20.
* <path> consists of lowercase English letters, dots and slashes. There are no two consecutive slashes, <path> doesn't start with a slash and its length doesn't exceed 20.
Addresses are not guaranteed to be distinct.
Output
First print k — the number of groups of server names that correspond to one website. You should count only groups of size greater than one.
Next k lines should contain the description of groups, one group per line. For each group print all server names separated by a single space. You are allowed to print both groups and names inside any group in arbitrary order.
Examples
Input
10
http://abacaba.ru/test
http://abacaba.ru/
http://abacaba.com
http://abacaba.com/test
http://abacaba.de/
http://abacaba.ru/test
http://abacaba.de/test
http://abacaba.com/
http://abacaba.com/t
http://abacaba.com/test
Output
1
http://abacaba.de http://abacaba.ru
Input
14
http://c
http://ccc.bbbb/aba..b
http://cba.com
http://a.c/aba..b/a
http://abc/
http://a.c/
http://ccc.bbbb
http://ab.ac.bc.aa/
http://a.a.a/
http://ccc.bbbb/
http://cba.com/
http://cba.com/aba..b
http://a.a.a/aba..b/a
http://abc/aba..b/a
Output
2
http://cba.com http://ccc.bbbb
http://a.a.a http://a.c http://abc
Submitted Solution:
```
n = int(input())
domains = {}
for _ in range(n):
request = input()[7:]
domain, sep, path = request.partition('/')
if domain in domains:
domains[domain].add(sep + path)
else:
domains[domain] = {sep + path}
path_hashes = []
for domain, paths in domains.items():
path_hashes.append(('|'.join(sorted(paths)), domain))
sorted_hashes = sorted(path_hashes, key=lambda x: x[0])
previous_hash = None
previous_domains = []
groups = []
for path_hash, domain in sorted_hashes:
if previous_hash == path_hash:
previous_domains.append(domain)
else:
previous_hash = path_hash
if len(previous_domains) > 1:
groups.append(previous_domains)
previous_domains = [domain]
if len(previous_domains) > 1:
groups.append(previous_domains)
print(len(groups))
print('\n'.join(map(lambda x: ' '.join(map(lambda y: 'http://' + y, x)), groups)))
```
Yes
| 50,105 | [
0.09423828125,
0.251953125,
-0.2147216796875,
0.234619140625,
-0.66015625,
-0.1405029296875,
-0.453857421875,
0.339599609375,
0.1724853515625,
0.7412109375,
0.2509765625,
0.05865478515625,
0.350830078125,
-0.53515625,
-0.845703125,
0.341064453125,
-0.490966796875,
-0.60791015625,
... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are some websites that are accessible through several different addresses. For example, for a long time Codeforces was accessible with two hostnames codeforces.com and codeforces.ru.
You are given a list of page addresses being queried. For simplicity we consider all addresses to have the form http://<hostname>[/<path>], where:
* <hostname> — server name (consists of words and maybe some dots separating them),
* /<path> — optional part, where <path> consists of words separated by slashes.
We consider two <hostname> to correspond to one website if for each query to the first <hostname> there will be exactly the same query to the second one and vice versa — for each query to the second <hostname> there will be the same query to the first one. Take a look at the samples for further clarifications.
Your goal is to determine the groups of server names that correspond to one website. Ignore groups consisting of the only server name.
Please note, that according to the above definition queries http://<hostname> and http://<hostname>/ are different.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 100 000) — the number of page queries. Then follow n lines each containing exactly one address. Each address is of the form http://<hostname>[/<path>], where:
* <hostname> consists of lowercase English letters and dots, there are no two consecutive dots, <hostname> doesn't start or finish with a dot. The length of <hostname> is positive and doesn't exceed 20.
* <path> consists of lowercase English letters, dots and slashes. There are no two consecutive slashes, <path> doesn't start with a slash and its length doesn't exceed 20.
Addresses are not guaranteed to be distinct.
Output
First print k — the number of groups of server names that correspond to one website. You should count only groups of size greater than one.
Next k lines should contain the description of groups, one group per line. For each group print all server names separated by a single space. You are allowed to print both groups and names inside any group in arbitrary order.
Examples
Input
10
http://abacaba.ru/test
http://abacaba.ru/
http://abacaba.com
http://abacaba.com/test
http://abacaba.de/
http://abacaba.ru/test
http://abacaba.de/test
http://abacaba.com/
http://abacaba.com/t
http://abacaba.com/test
Output
1
http://abacaba.de http://abacaba.ru
Input
14
http://c
http://ccc.bbbb/aba..b
http://cba.com
http://a.c/aba..b/a
http://abc/
http://a.c/
http://ccc.bbbb
http://ab.ac.bc.aa/
http://a.a.a/
http://ccc.bbbb/
http://cba.com/
http://cba.com/aba..b
http://a.a.a/aba..b/a
http://abc/aba..b/a
Output
2
http://cba.com http://ccc.bbbb
http://a.a.a http://a.c http://abc
Submitted Solution:
```
import sys
from urllib.parse import urlparse
import itertools as itt
def main():
n = int(sys.stdin.readline().strip())
links = [sys.stdin.readline().strip() for i in range(n)]
host_queries = {}
for link in links:
p = urlparse(link)
host = "http://" + p.netloc
query = p.path
if not host in host_queries:
host_queries[host] = set()
host_queries[host].add(query)
hosts = host_queries.keys()
hosts = list(sorted(hosts, key=lambda h: "-".join(sorted(host_queries[h]))))
groups = []
for key, group in itt.groupby(hosts, key=lambda h: "-".join(sorted(host_queries[h]))):
g = list(group)
if len(g) < 2:
continue
groups.append(g)
print(len(groups))
for g in groups:
print(" ".join(g))
if __name__ == "__main__":
main()
```
Yes
| 50,106 | [
0.09423828125,
0.251953125,
-0.2147216796875,
0.234619140625,
-0.66015625,
-0.1405029296875,
-0.453857421875,
0.339599609375,
0.1724853515625,
0.7412109375,
0.2509765625,
0.05865478515625,
0.350830078125,
-0.53515625,
-0.845703125,
0.341064453125,
-0.490966796875,
-0.60791015625,
... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are some websites that are accessible through several different addresses. For example, for a long time Codeforces was accessible with two hostnames codeforces.com and codeforces.ru.
You are given a list of page addresses being queried. For simplicity we consider all addresses to have the form http://<hostname>[/<path>], where:
* <hostname> — server name (consists of words and maybe some dots separating them),
* /<path> — optional part, where <path> consists of words separated by slashes.
We consider two <hostname> to correspond to one website if for each query to the first <hostname> there will be exactly the same query to the second one and vice versa — for each query to the second <hostname> there will be the same query to the first one. Take a look at the samples for further clarifications.
Your goal is to determine the groups of server names that correspond to one website. Ignore groups consisting of the only server name.
Please note, that according to the above definition queries http://<hostname> and http://<hostname>/ are different.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 100 000) — the number of page queries. Then follow n lines each containing exactly one address. Each address is of the form http://<hostname>[/<path>], where:
* <hostname> consists of lowercase English letters and dots, there are no two consecutive dots, <hostname> doesn't start or finish with a dot. The length of <hostname> is positive and doesn't exceed 20.
* <path> consists of lowercase English letters, dots and slashes. There are no two consecutive slashes, <path> doesn't start with a slash and its length doesn't exceed 20.
Addresses are not guaranteed to be distinct.
Output
First print k — the number of groups of server names that correspond to one website. You should count only groups of size greater than one.
Next k lines should contain the description of groups, one group per line. For each group print all server names separated by a single space. You are allowed to print both groups and names inside any group in arbitrary order.
Examples
Input
10
http://abacaba.ru/test
http://abacaba.ru/
http://abacaba.com
http://abacaba.com/test
http://abacaba.de/
http://abacaba.ru/test
http://abacaba.de/test
http://abacaba.com/
http://abacaba.com/t
http://abacaba.com/test
Output
1
http://abacaba.de http://abacaba.ru
Input
14
http://c
http://ccc.bbbb/aba..b
http://cba.com
http://a.c/aba..b/a
http://abc/
http://a.c/
http://ccc.bbbb
http://ab.ac.bc.aa/
http://a.a.a/
http://ccc.bbbb/
http://cba.com/
http://cba.com/aba..b
http://a.a.a/aba..b/a
http://abc/aba..b/a
Output
2
http://cba.com http://ccc.bbbb
http://a.a.a http://a.c http://abc
Submitted Solution:
```
import sys
n = int(input())
domains = {}
for full_request in sys.stdin:
request = full_request[7:]
domain, sep, path = request.partition('/')
if domain in domains:
domains[domain].add(sep + path)
else:
domains[domain] = {sep + path}
path_hashes = []
for domain, paths in domains.items():
path_hashes.append(('|'.join(sorted(paths)), domain))
sorted_hashes = sorted(path_hashes, key=lambda x: x[0])
previous_hash = None
previous_domains = []
groups = []
for path_hash, domain in sorted_hashes:
if previous_hash == path_hash:
previous_domains.append(domain)
else:
previous_hash = path_hash
if len(previous_domains) > 1:
groups.append(previous_domains)
previous_domains = [domain]
if len(previous_domains) > 1:
groups.append(previous_domains)
print(len(groups))
print('\n'.join(map(lambda x: ' '.join(map(lambda y: 'http://' + y, x)), groups)))
```
No
| 50,107 | [
0.09423828125,
0.251953125,
-0.2147216796875,
0.234619140625,
-0.66015625,
-0.1405029296875,
-0.453857421875,
0.339599609375,
0.1724853515625,
0.7412109375,
0.2509765625,
0.05865478515625,
0.350830078125,
-0.53515625,
-0.845703125,
0.341064453125,
-0.490966796875,
-0.60791015625,
... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are some websites that are accessible through several different addresses. For example, for a long time Codeforces was accessible with two hostnames codeforces.com and codeforces.ru.
You are given a list of page addresses being queried. For simplicity we consider all addresses to have the form http://<hostname>[/<path>], where:
* <hostname> — server name (consists of words and maybe some dots separating them),
* /<path> — optional part, where <path> consists of words separated by slashes.
We consider two <hostname> to correspond to one website if for each query to the first <hostname> there will be exactly the same query to the second one and vice versa — for each query to the second <hostname> there will be the same query to the first one. Take a look at the samples for further clarifications.
Your goal is to determine the groups of server names that correspond to one website. Ignore groups consisting of the only server name.
Please note, that according to the above definition queries http://<hostname> and http://<hostname>/ are different.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 100 000) — the number of page queries. Then follow n lines each containing exactly one address. Each address is of the form http://<hostname>[/<path>], where:
* <hostname> consists of lowercase English letters and dots, there are no two consecutive dots, <hostname> doesn't start or finish with a dot. The length of <hostname> is positive and doesn't exceed 20.
* <path> consists of lowercase English letters, dots and slashes. There are no two consecutive slashes, <path> doesn't start with a slash and its length doesn't exceed 20.
Addresses are not guaranteed to be distinct.
Output
First print k — the number of groups of server names that correspond to one website. You should count only groups of size greater than one.
Next k lines should contain the description of groups, one group per line. For each group print all server names separated by a single space. You are allowed to print both groups and names inside any group in arbitrary order.
Examples
Input
10
http://abacaba.ru/test
http://abacaba.ru/
http://abacaba.com
http://abacaba.com/test
http://abacaba.de/
http://abacaba.ru/test
http://abacaba.de/test
http://abacaba.com/
http://abacaba.com/t
http://abacaba.com/test
Output
1
http://abacaba.de http://abacaba.ru
Input
14
http://c
http://ccc.bbbb/aba..b
http://cba.com
http://a.c/aba..b/a
http://abc/
http://a.c/
http://ccc.bbbb
http://ab.ac.bc.aa/
http://a.a.a/
http://ccc.bbbb/
http://cba.com/
http://cba.com/aba..b
http://a.a.a/aba..b/a
http://abc/aba..b/a
Output
2
http://cba.com http://ccc.bbbb
http://a.a.a http://a.c http://abc
Submitted Solution:
```
from sys import stdin
def main():
l = stdin.read().splitlines()
a = t = l[0] = '~'
l.sort()
r, pp = [], [a]
for b in map(str.rstrip, l):
if a == b:
continue
a = b
i = a.find('/', 7)
h, p = (a, '') if i == -1 else (a[:i], a[i:])
# if h == 'http://ip':
# print(repr(h), repr(p))
if t == h:
pp.append(p)
else:
r.append((' '.join(pp), t))
t, pp = h, [p]
r.sort()
l, s = [], []
for p, h in r:
if h in ('http://ip', 'http://c.r.naey'):
print(repr(h), repr(p))
if t == p:
s.append(h)
else:
if len(s) > 1:
l.append(' '.join(s))
t, s = p, [h]
print(len(l))
print('\n'.join(l))
if __name__ == '__main__':
main()
```
No
| 50,108 | [
0.09423828125,
0.251953125,
-0.2147216796875,
0.234619140625,
-0.66015625,
-0.1405029296875,
-0.453857421875,
0.339599609375,
0.1724853515625,
0.7412109375,
0.2509765625,
0.05865478515625,
0.350830078125,
-0.53515625,
-0.845703125,
0.341064453125,
-0.490966796875,
-0.60791015625,
... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are some websites that are accessible through several different addresses. For example, for a long time Codeforces was accessible with two hostnames codeforces.com and codeforces.ru.
You are given a list of page addresses being queried. For simplicity we consider all addresses to have the form http://<hostname>[/<path>], where:
* <hostname> — server name (consists of words and maybe some dots separating them),
* /<path> — optional part, where <path> consists of words separated by slashes.
We consider two <hostname> to correspond to one website if for each query to the first <hostname> there will be exactly the same query to the second one and vice versa — for each query to the second <hostname> there will be the same query to the first one. Take a look at the samples for further clarifications.
Your goal is to determine the groups of server names that correspond to one website. Ignore groups consisting of the only server name.
Please note, that according to the above definition queries http://<hostname> and http://<hostname>/ are different.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 100 000) — the number of page queries. Then follow n lines each containing exactly one address. Each address is of the form http://<hostname>[/<path>], where:
* <hostname> consists of lowercase English letters and dots, there are no two consecutive dots, <hostname> doesn't start or finish with a dot. The length of <hostname> is positive and doesn't exceed 20.
* <path> consists of lowercase English letters, dots and slashes. There are no two consecutive slashes, <path> doesn't start with a slash and its length doesn't exceed 20.
Addresses are not guaranteed to be distinct.
Output
First print k — the number of groups of server names that correspond to one website. You should count only groups of size greater than one.
Next k lines should contain the description of groups, one group per line. For each group print all server names separated by a single space. You are allowed to print both groups and names inside any group in arbitrary order.
Examples
Input
10
http://abacaba.ru/test
http://abacaba.ru/
http://abacaba.com
http://abacaba.com/test
http://abacaba.de/
http://abacaba.ru/test
http://abacaba.de/test
http://abacaba.com/
http://abacaba.com/t
http://abacaba.com/test
Output
1
http://abacaba.de http://abacaba.ru
Input
14
http://c
http://ccc.bbbb/aba..b
http://cba.com
http://a.c/aba..b/a
http://abc/
http://a.c/
http://ccc.bbbb
http://ab.ac.bc.aa/
http://a.a.a/
http://ccc.bbbb/
http://cba.com/
http://cba.com/aba..b
http://a.a.a/aba..b/a
http://abc/aba..b/a
Output
2
http://cba.com http://ccc.bbbb
http://a.a.a http://a.c http://abc
Submitted Solution:
```
from sys import stdin
def main():
l = stdin.read().splitlines()
ptrn = a = l[0] = '~'
l.sort()
r, pp = [], [a]
for b in l:
if a == b:
continue
a = b
i = a.find('/', 8)
if i == -1:
h, p = a, ''
else:
h, p = a[:i], a[i:]
if ptrn == h:
pp.append(p)
else:
r.append(('+'.join(sorted(pp)), ptrn))
ptrn, pp = h, [p]
r.sort()
l, res = [], []
for p, h in r:
if ptrn == p:
l.append(h)
else:
if len(l) > 1:
res.append(' '.join(l))
ptrn, l = p, [h]
print(len(res))
print('\n'.join(res))
if __name__ == '__main__':
main()
```
No
| 50,109 | [
0.09423828125,
0.251953125,
-0.2147216796875,
0.234619140625,
-0.66015625,
-0.1405029296875,
-0.453857421875,
0.339599609375,
0.1724853515625,
0.7412109375,
0.2509765625,
0.05865478515625,
0.350830078125,
-0.53515625,
-0.845703125,
0.341064453125,
-0.490966796875,
-0.60791015625,
... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are some websites that are accessible through several different addresses. For example, for a long time Codeforces was accessible with two hostnames codeforces.com and codeforces.ru.
You are given a list of page addresses being queried. For simplicity we consider all addresses to have the form http://<hostname>[/<path>], where:
* <hostname> — server name (consists of words and maybe some dots separating them),
* /<path> — optional part, where <path> consists of words separated by slashes.
We consider two <hostname> to correspond to one website if for each query to the first <hostname> there will be exactly the same query to the second one and vice versa — for each query to the second <hostname> there will be the same query to the first one. Take a look at the samples for further clarifications.
Your goal is to determine the groups of server names that correspond to one website. Ignore groups consisting of the only server name.
Please note, that according to the above definition queries http://<hostname> and http://<hostname>/ are different.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 100 000) — the number of page queries. Then follow n lines each containing exactly one address. Each address is of the form http://<hostname>[/<path>], where:
* <hostname> consists of lowercase English letters and dots, there are no two consecutive dots, <hostname> doesn't start or finish with a dot. The length of <hostname> is positive and doesn't exceed 20.
* <path> consists of lowercase English letters, dots and slashes. There are no two consecutive slashes, <path> doesn't start with a slash and its length doesn't exceed 20.
Addresses are not guaranteed to be distinct.
Output
First print k — the number of groups of server names that correspond to one website. You should count only groups of size greater than one.
Next k lines should contain the description of groups, one group per line. For each group print all server names separated by a single space. You are allowed to print both groups and names inside any group in arbitrary order.
Examples
Input
10
http://abacaba.ru/test
http://abacaba.ru/
http://abacaba.com
http://abacaba.com/test
http://abacaba.de/
http://abacaba.ru/test
http://abacaba.de/test
http://abacaba.com/
http://abacaba.com/t
http://abacaba.com/test
Output
1
http://abacaba.de http://abacaba.ru
Input
14
http://c
http://ccc.bbbb/aba..b
http://cba.com
http://a.c/aba..b/a
http://abc/
http://a.c/
http://ccc.bbbb
http://ab.ac.bc.aa/
http://a.a.a/
http://ccc.bbbb/
http://cba.com/
http://cba.com/aba..b
http://a.a.a/aba..b/a
http://abc/aba..b/a
Output
2
http://cba.com http://ccc.bbbb
http://a.a.a http://a.c http://abc
Submitted Solution:
```
import sys
from urllib.parse import urlparse
import itertools as itt
def main():
n = int(sys.stdin.readline().strip())
links = [sys.stdin.readline().strip() for i in range(n)]
host_queries = {}
for link in links:
p = urlparse(link)
host = "http://" + p.netloc
query = p.path[1:]
if not host in host_queries:
host_queries[host] = set()
host_queries[host].add(query)
hosts = host_queries.keys()
hosts = list(sorted(hosts, key=lambda h: host_queries[h]))
groups = []
for key, group in itt.groupby(hosts, key=lambda h: host_queries[h]):
g = list(group)
if len(g) < 2:
continue
groups.append(g)
print(len(groups))
for g in groups:
print(" ".join(g))
if __name__ == "__main__":
main()
```
No
| 50,110 | [
0.09423828125,
0.251953125,
-0.2147216796875,
0.234619140625,
-0.66015625,
-0.1405029296875,
-0.453857421875,
0.339599609375,
0.1724853515625,
0.7412109375,
0.2509765625,
0.05865478515625,
0.350830078125,
-0.53515625,
-0.845703125,
0.341064453125,
-0.490966796875,
-0.60791015625,
... | 11 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are an experienced Codeforces user. Today you found out that during your activity on Codeforces you have made y submissions, out of which x have been successful. Thus, your current success rate on Codeforces is equal to x / y.
Your favorite rational number in the [0;1] range is p / q. Now you wonder: what is the smallest number of submissions you have to make if you want your success rate to be p / q?
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
Each of the next t lines contains four integers x, y, p and q (0 ≤ x ≤ y ≤ 109; 0 ≤ p ≤ q ≤ 109; y > 0; q > 0).
It is guaranteed that p / q is an irreducible fraction.
Hacks. For hacks, an additional constraint of t ≤ 5 must be met.
Output
For each test case, output a single integer equal to the smallest number of submissions you have to make if you want your success rate to be equal to your favorite rational number, or -1 if this is impossible to achieve.
Example
Input
4
3 10 1 2
7 14 3 8
20 70 2 7
5 6 1 1
Output
4
10
0
-1
Note
In the first example, you have to make 4 successful submissions. Your success rate will be equal to 7 / 14, or 1 / 2.
In the second example, you have to make 2 successful and 8 unsuccessful submissions. Your success rate will be equal to 9 / 24, or 3 / 8.
In the third example, there is no need to make any new submissions. Your success rate is already equal to 20 / 70, or 2 / 7.
In the fourth example, the only unsuccessful submission breaks your hopes of having the success rate equal to 1.
Tags: binary search, math
Correct Solution:
```
import sys
def solve():
t = int(sys.stdin.readline())
for ti in range(t):
x, y, p, q = map(int, sys.stdin.readline().split())
if p == 0: # p/q = 0
if x == 0:
print(0)
else:
print(-1)
continue
if p == q: # p/q = 1
if x == y:
print(0)
else:
print(-1)
continue
if p*y == x*q: # p/q = x/y
print(0)
elif p*y > x*q: # p/q > x/y
z = (q*(y - x) + q - p - 1) // (q - p)
ans = (z + q - 1) // q * q - y
print(ans)
else: # p/q < x/y
z = (q*x + p - 1) // p
ans = (z + q - 1) // q * q - y
print(ans)
if __name__ == '__main__':
solve()
```
| 50,156 | [
0.30517578125,
-0.1265869140625,
0.034088134765625,
0.333740234375,
-0.68359375,
-0.47119140625,
-0.2283935546875,
0.1700439453125,
0.09381103515625,
0.83349609375,
0.58984375,
0.1116943359375,
0.09515380859375,
-0.50244140625,
-0.1917724609375,
0.440673828125,
-0.05364990234375,
-... | 11 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are an experienced Codeforces user. Today you found out that during your activity on Codeforces you have made y submissions, out of which x have been successful. Thus, your current success rate on Codeforces is equal to x / y.
Your favorite rational number in the [0;1] range is p / q. Now you wonder: what is the smallest number of submissions you have to make if you want your success rate to be p / q?
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
Each of the next t lines contains four integers x, y, p and q (0 ≤ x ≤ y ≤ 109; 0 ≤ p ≤ q ≤ 109; y > 0; q > 0).
It is guaranteed that p / q is an irreducible fraction.
Hacks. For hacks, an additional constraint of t ≤ 5 must be met.
Output
For each test case, output a single integer equal to the smallest number of submissions you have to make if you want your success rate to be equal to your favorite rational number, or -1 if this is impossible to achieve.
Example
Input
4
3 10 1 2
7 14 3 8
20 70 2 7
5 6 1 1
Output
4
10
0
-1
Note
In the first example, you have to make 4 successful submissions. Your success rate will be equal to 7 / 14, or 1 / 2.
In the second example, you have to make 2 successful and 8 unsuccessful submissions. Your success rate will be equal to 9 / 24, or 3 / 8.
In the third example, there is no need to make any new submissions. Your success rate is already equal to 20 / 70, or 2 / 7.
In the fourth example, the only unsuccessful submission breaks your hopes of having the success rate equal to 1.
Tags: binary search, math
Correct Solution:
```
import math
def main():
T = int(input())
for t in range(T):
solve()
def solve():
x, y, p, q = map(int, input().split())
if p == 1 and q == 1:
if x == y:
print(0)
else:
print(-1)
return
if p == 0 and q == 1:
if x == 0:
print(0)
else:
print(-1)
return
# n = max(math.ceil(y/q), math.ceil(x/p))
# while (n*q - y) < (n*p -x):
# n += 1
n = max(math.ceil(y/q), math.ceil(x/p), math.ceil((y-x)/(q-p)))
print(n*q-y)
if __name__ == "__main__":
# global stime
# stime = time.clock()
main()
```
| 50,157 | [
0.3115234375,
-0.152587890625,
-0.040313720703125,
0.347900390625,
-0.60302734375,
-0.407958984375,
-0.1627197265625,
0.15869140625,
0.1334228515625,
0.82958984375,
0.62744140625,
0.096435546875,
0.110107421875,
-0.5205078125,
-0.15966796875,
0.432373046875,
-0.10308837890625,
-0.5... | 11 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are an experienced Codeforces user. Today you found out that during your activity on Codeforces you have made y submissions, out of which x have been successful. Thus, your current success rate on Codeforces is equal to x / y.
Your favorite rational number in the [0;1] range is p / q. Now you wonder: what is the smallest number of submissions you have to make if you want your success rate to be p / q?
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
Each of the next t lines contains four integers x, y, p and q (0 ≤ x ≤ y ≤ 109; 0 ≤ p ≤ q ≤ 109; y > 0; q > 0).
It is guaranteed that p / q is an irreducible fraction.
Hacks. For hacks, an additional constraint of t ≤ 5 must be met.
Output
For each test case, output a single integer equal to the smallest number of submissions you have to make if you want your success rate to be equal to your favorite rational number, or -1 if this is impossible to achieve.
Example
Input
4
3 10 1 2
7 14 3 8
20 70 2 7
5 6 1 1
Output
4
10
0
-1
Note
In the first example, you have to make 4 successful submissions. Your success rate will be equal to 7 / 14, or 1 / 2.
In the second example, you have to make 2 successful and 8 unsuccessful submissions. Your success rate will be equal to 9 / 24, or 3 / 8.
In the third example, there is no need to make any new submissions. Your success rate is already equal to 20 / 70, or 2 / 7.
In the fourth example, the only unsuccessful submission breaks your hopes of having the success rate equal to 1.
Tags: binary search, math
Correct Solution:
```
import math
def result():
x, y, p, q = map(int, input().split())
if p == 1 and q == 1:
if x == y:
print(0)
else:
print(-1)
return
if p == 0 and q == 1:
if x == 0:
print(0)
else:
print(-1)
return
n = max(math.ceil(y/q), math.ceil(x/p), math.ceil((y-x)/(q-p)))
print(n*q-y)
t = int(input())
for i in range(t):
result()
```
| 50,158 | [
0.27587890625,
-0.1260986328125,
-0.014862060546875,
0.380615234375,
-0.63916015625,
-0.439208984375,
-0.1563720703125,
0.1546630859375,
0.10699462890625,
0.83349609375,
0.61962890625,
0.13330078125,
0.07666015625,
-0.494140625,
-0.1483154296875,
0.381103515625,
-0.1002197265625,
-... | 11 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are an experienced Codeforces user. Today you found out that during your activity on Codeforces you have made y submissions, out of which x have been successful. Thus, your current success rate on Codeforces is equal to x / y.
Your favorite rational number in the [0;1] range is p / q. Now you wonder: what is the smallest number of submissions you have to make if you want your success rate to be p / q?
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
Each of the next t lines contains four integers x, y, p and q (0 ≤ x ≤ y ≤ 109; 0 ≤ p ≤ q ≤ 109; y > 0; q > 0).
It is guaranteed that p / q is an irreducible fraction.
Hacks. For hacks, an additional constraint of t ≤ 5 must be met.
Output
For each test case, output a single integer equal to the smallest number of submissions you have to make if you want your success rate to be equal to your favorite rational number, or -1 if this is impossible to achieve.
Example
Input
4
3 10 1 2
7 14 3 8
20 70 2 7
5 6 1 1
Output
4
10
0
-1
Note
In the first example, you have to make 4 successful submissions. Your success rate will be equal to 7 / 14, or 1 / 2.
In the second example, you have to make 2 successful and 8 unsuccessful submissions. Your success rate will be equal to 9 / 24, or 3 / 8.
In the third example, there is no need to make any new submissions. Your success rate is already equal to 20 / 70, or 2 / 7.
In the fourth example, the only unsuccessful submission breaks your hopes of having the success rate equal to 1.
Tags: binary search, math
Correct Solution:
```
for _ in range(int(input())):
x, y, p, q = map(int, input().split())
d = q * int(1e9)
c = p * int(1e9)
if not (c >= x and d - y >= c - x):
print(-1)
continue
i = -1
j = int(1e9)
while j - i > 1:
m = (i + j) // 2
d = q * m
c = p * m
if c >= x and d - y >= c - x:
j = m
else:
i = m
print(j * q - y)
```
| 50,159 | [
0.30322265625,
-0.148193359375,
-0.046417236328125,
0.352294921875,
-0.65087890625,
-0.471923828125,
-0.1478271484375,
0.11328125,
0.0975341796875,
0.84619140625,
0.61767578125,
0.11651611328125,
0.0882568359375,
-0.5380859375,
-0.1728515625,
0.436279296875,
-0.0848388671875,
-0.53... | 11 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are an experienced Codeforces user. Today you found out that during your activity on Codeforces you have made y submissions, out of which x have been successful. Thus, your current success rate on Codeforces is equal to x / y.
Your favorite rational number in the [0;1] range is p / q. Now you wonder: what is the smallest number of submissions you have to make if you want your success rate to be p / q?
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
Each of the next t lines contains four integers x, y, p and q (0 ≤ x ≤ y ≤ 109; 0 ≤ p ≤ q ≤ 109; y > 0; q > 0).
It is guaranteed that p / q is an irreducible fraction.
Hacks. For hacks, an additional constraint of t ≤ 5 must be met.
Output
For each test case, output a single integer equal to the smallest number of submissions you have to make if you want your success rate to be equal to your favorite rational number, or -1 if this is impossible to achieve.
Example
Input
4
3 10 1 2
7 14 3 8
20 70 2 7
5 6 1 1
Output
4
10
0
-1
Note
In the first example, you have to make 4 successful submissions. Your success rate will be equal to 7 / 14, or 1 / 2.
In the second example, you have to make 2 successful and 8 unsuccessful submissions. Your success rate will be equal to 9 / 24, or 3 / 8.
In the third example, there is no need to make any new submissions. Your success rate is already equal to 20 / 70, or 2 / 7.
In the fourth example, the only unsuccessful submission breaks your hopes of having the success rate equal to 1.
Tags: binary search, math
Correct Solution:
```
for _ in range(int(input())):
x,y,p,q=map(int,input().split())
l,r,res=0,10**18,-1
while l<=r:
mid=(l+r)//2
a,b=p*mid-x,q*mid-y
if a<=b and a>-1 and b>-1:res=b;r=mid-1
else :l=mid+1
print(res)
```
| 50,160 | [
0.30615234375,
-0.144287109375,
-0.03704833984375,
0.3798828125,
-0.69677734375,
-0.5107421875,
-0.1583251953125,
0.099853515625,
0.09161376953125,
0.85595703125,
0.60888671875,
0.13232421875,
0.0963134765625,
-0.54052734375,
-0.2147216796875,
0.447021484375,
-0.057220458984375,
-0... | 11 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are an experienced Codeforces user. Today you found out that during your activity on Codeforces you have made y submissions, out of which x have been successful. Thus, your current success rate on Codeforces is equal to x / y.
Your favorite rational number in the [0;1] range is p / q. Now you wonder: what is the smallest number of submissions you have to make if you want your success rate to be p / q?
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
Each of the next t lines contains four integers x, y, p and q (0 ≤ x ≤ y ≤ 109; 0 ≤ p ≤ q ≤ 109; y > 0; q > 0).
It is guaranteed that p / q is an irreducible fraction.
Hacks. For hacks, an additional constraint of t ≤ 5 must be met.
Output
For each test case, output a single integer equal to the smallest number of submissions you have to make if you want your success rate to be equal to your favorite rational number, or -1 if this is impossible to achieve.
Example
Input
4
3 10 1 2
7 14 3 8
20 70 2 7
5 6 1 1
Output
4
10
0
-1
Note
In the first example, you have to make 4 successful submissions. Your success rate will be equal to 7 / 14, or 1 / 2.
In the second example, you have to make 2 successful and 8 unsuccessful submissions. Your success rate will be equal to 9 / 24, or 3 / 8.
In the third example, there is no need to make any new submissions. Your success rate is already equal to 20 / 70, or 2 / 7.
In the fourth example, the only unsuccessful submission breaks your hopes of having the success rate equal to 1.
Tags: binary search, math
Correct Solution:
```
MAXN = int(2e18)
def check(n, x, y, p, q):
np, nq = n * p, n * q
# print(x, y, np, nq)
if nq < y:
return False
diff = nq - y
return x <= np <= x + diff
def solve():
x, y, p, q = map(int, input().split())
l, r = 1, int(MAXN)
while l != r:
m = (l + r) // 2
if not check(m, x, y, p, q):
l = m + 1
else:
r = m
if r == MAXN:
print(-1)
else:
print(l * q - y)
t = int(input())
for _ in range(t):
solve()
```
| 50,161 | [
0.3076171875,
-0.1343994140625,
-0.0203094482421875,
0.387939453125,
-0.591796875,
-0.52685546875,
-0.138427734375,
0.0718994140625,
0.1875,
0.87841796875,
0.62255859375,
0.1370849609375,
0.095458984375,
-0.52978515625,
-0.1585693359375,
0.436279296875,
-0.10858154296875,
-0.595214... | 11 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are an experienced Codeforces user. Today you found out that during your activity on Codeforces you have made y submissions, out of which x have been successful. Thus, your current success rate on Codeforces is equal to x / y.
Your favorite rational number in the [0;1] range is p / q. Now you wonder: what is the smallest number of submissions you have to make if you want your success rate to be p / q?
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
Each of the next t lines contains four integers x, y, p and q (0 ≤ x ≤ y ≤ 109; 0 ≤ p ≤ q ≤ 109; y > 0; q > 0).
It is guaranteed that p / q is an irreducible fraction.
Hacks. For hacks, an additional constraint of t ≤ 5 must be met.
Output
For each test case, output a single integer equal to the smallest number of submissions you have to make if you want your success rate to be equal to your favorite rational number, or -1 if this is impossible to achieve.
Example
Input
4
3 10 1 2
7 14 3 8
20 70 2 7
5 6 1 1
Output
4
10
0
-1
Note
In the first example, you have to make 4 successful submissions. Your success rate will be equal to 7 / 14, or 1 / 2.
In the second example, you have to make 2 successful and 8 unsuccessful submissions. Your success rate will be equal to 9 / 24, or 3 / 8.
In the third example, there is no need to make any new submissions. Your success rate is already equal to 20 / 70, or 2 / 7.
In the fourth example, the only unsuccessful submission breaks your hopes of having the success rate equal to 1.
Tags: binary search, math
Correct Solution:
```
tc = int(input())
for i in range(tc):
x, y, p, q = map(int, input().split())
if p == 0:
if x == 0:
print('0')
else:
print('-1')
elif p == q:
if y > x:
print('-1')
else:
print('0')
elif p * y == x * q:
print('0')
else:
#newy = y
#while True:
# newy += q - (newy % q)
# newx = (newy // q) * p
# if 0 <= newx - x <= newy - y:
# print(str(newy - y))
# break
def minmax(lob, hib):
if lob == hib:
return lob - y
lower = (lob + hib) // 2
higher = lower + q - (lower % q)
lower = higher - q
newxh = (higher // q) * p
if 0 <= newxh - x <= higher - y:
newxl = (lower // q) * p
if 0 <= newxl - x <= lower - y:
return minmax(lob, lower)
else:
return higher - y
else:
return minmax(higher, hib)
lob = y + q - (y % q)
hib = 10**19 + q - (10**19 % q)
print(str(minmax(lob, hib)))
```
| 50,162 | [
0.311767578125,
-0.143798828125,
-0.045684814453125,
0.341064453125,
-0.65087890625,
-0.421142578125,
-0.14599609375,
0.1348876953125,
0.076416015625,
0.814453125,
0.6455078125,
0.1014404296875,
0.08782958984375,
-0.51611328125,
-0.1773681640625,
0.392578125,
-0.1329345703125,
-0.5... | 11 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are an experienced Codeforces user. Today you found out that during your activity on Codeforces you have made y submissions, out of which x have been successful. Thus, your current success rate on Codeforces is equal to x / y.
Your favorite rational number in the [0;1] range is p / q. Now you wonder: what is the smallest number of submissions you have to make if you want your success rate to be p / q?
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
Each of the next t lines contains four integers x, y, p and q (0 ≤ x ≤ y ≤ 109; 0 ≤ p ≤ q ≤ 109; y > 0; q > 0).
It is guaranteed that p / q is an irreducible fraction.
Hacks. For hacks, an additional constraint of t ≤ 5 must be met.
Output
For each test case, output a single integer equal to the smallest number of submissions you have to make if you want your success rate to be equal to your favorite rational number, or -1 if this is impossible to achieve.
Example
Input
4
3 10 1 2
7 14 3 8
20 70 2 7
5 6 1 1
Output
4
10
0
-1
Note
In the first example, you have to make 4 successful submissions. Your success rate will be equal to 7 / 14, or 1 / 2.
In the second example, you have to make 2 successful and 8 unsuccessful submissions. Your success rate will be equal to 9 / 24, or 3 / 8.
In the third example, there is no need to make any new submissions. Your success rate is already equal to 20 / 70, or 2 / 7.
In the fourth example, the only unsuccessful submission breaks your hopes of having the success rate equal to 1.
Tags: binary search, math
Correct Solution:
```
def ext_gcd(a, b):
if a == 0:
return b, 0, 1
else:
g, x, y = ext_gcd(b % a, a)
return g, y - (b // a) * x, x
def multinv(b, n):
g, x, trash = ext_gcd(b, n)
return x % n
def solve():
x, y, p, q = map(int, input().split(' '))
if p == q:
if x == y:
return 0
else:
return -1
if p == 0:
if x == 0:
return 0
else:
return -1
c = p * y - q * x
a = (multinv(q, p) * c ) % p
if ((q*a)-c)//p < a:
dif = (c//(q-p) - a)
dif = dif//p
a += p * (dif-3)
while ((q*a)-c)//p < a or a < 0:
a += p
return ((q*a)-c)//p
t = int(input())
for a0 in range(t):
print(solve())
```
| 50,163 | [
0.2420654296875,
-0.1737060546875,
0.0303497314453125,
0.41650390625,
-0.5771484375,
-0.442138671875,
-0.1407470703125,
0.034759521484375,
0.1756591796875,
0.931640625,
0.63427734375,
0.009674072265625,
0.10638427734375,
-0.55126953125,
-0.14697265625,
0.49267578125,
-0.0687866210937... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are an experienced Codeforces user. Today you found out that during your activity on Codeforces you have made y submissions, out of which x have been successful. Thus, your current success rate on Codeforces is equal to x / y.
Your favorite rational number in the [0;1] range is p / q. Now you wonder: what is the smallest number of submissions you have to make if you want your success rate to be p / q?
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
Each of the next t lines contains four integers x, y, p and q (0 ≤ x ≤ y ≤ 109; 0 ≤ p ≤ q ≤ 109; y > 0; q > 0).
It is guaranteed that p / q is an irreducible fraction.
Hacks. For hacks, an additional constraint of t ≤ 5 must be met.
Output
For each test case, output a single integer equal to the smallest number of submissions you have to make if you want your success rate to be equal to your favorite rational number, or -1 if this is impossible to achieve.
Example
Input
4
3 10 1 2
7 14 3 8
20 70 2 7
5 6 1 1
Output
4
10
0
-1
Note
In the first example, you have to make 4 successful submissions. Your success rate will be equal to 7 / 14, or 1 / 2.
In the second example, you have to make 2 successful and 8 unsuccessful submissions. Your success rate will be equal to 9 / 24, or 3 / 8.
In the third example, there is no need to make any new submissions. Your success rate is already equal to 20 / 70, or 2 / 7.
In the fourth example, the only unsuccessful submission breaks your hopes of having the success rate equal to 1.
Submitted Solution:
```
t = int(input())
for zz in range(t):
x, y, p, q = [int(i) for i in input().split()]
if (x*q == y*p):print(0)
elif ((p == 0 and x != 0) or (p == q and x != y)): print(-1)
else:
sel1 = y-x;
sel2 = q-p;
kalr = x // p + (0, 1)[x % p != 0]
kalr = max(kalr, sel1 // sel2 + (0, 1)[sel1 % sel2 != 0])
q *= kalr
print(q-y)
```
Yes
| 50,164 | [
0.32958984375,
-0.152587890625,
-0.01971435546875,
0.2159423828125,
-0.76416015625,
-0.385498046875,
-0.28076171875,
0.264892578125,
-0.0275421142578125,
0.79248046875,
0.486083984375,
0.1246337890625,
0.11224365234375,
-0.495849609375,
-0.2301025390625,
0.404296875,
-0.0758666992187... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are an experienced Codeforces user. Today you found out that during your activity on Codeforces you have made y submissions, out of which x have been successful. Thus, your current success rate on Codeforces is equal to x / y.
Your favorite rational number in the [0;1] range is p / q. Now you wonder: what is the smallest number of submissions you have to make if you want your success rate to be p / q?
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
Each of the next t lines contains four integers x, y, p and q (0 ≤ x ≤ y ≤ 109; 0 ≤ p ≤ q ≤ 109; y > 0; q > 0).
It is guaranteed that p / q is an irreducible fraction.
Hacks. For hacks, an additional constraint of t ≤ 5 must be met.
Output
For each test case, output a single integer equal to the smallest number of submissions you have to make if you want your success rate to be equal to your favorite rational number, or -1 if this is impossible to achieve.
Example
Input
4
3 10 1 2
7 14 3 8
20 70 2 7
5 6 1 1
Output
4
10
0
-1
Note
In the first example, you have to make 4 successful submissions. Your success rate will be equal to 7 / 14, or 1 / 2.
In the second example, you have to make 2 successful and 8 unsuccessful submissions. Your success rate will be equal to 9 / 24, or 3 / 8.
In the third example, there is no need to make any new submissions. Your success rate is already equal to 20 / 70, or 2 / 7.
In the fourth example, the only unsuccessful submission breaks your hopes of having the success rate equal to 1.
Submitted Solution:
```
t = int(input())
for _ in range(t):
x, y, p, q = map(int, input().split())
if p == q:
print(0 if x == y else -1)
elif p == 0:
print(0 if x == 0 else -1)
elif x * q == y * p:
print(0)
else:
l = 0
r = 2**64
cnt = 0
while l + 1 < r:
cnt += 1
c = (l + r) // 2
if x <= c * p <= x + c * q - y:
r = c
else:
l = c
print(r * q - y)
```
Yes
| 50,165 | [
0.306640625,
-0.14990234375,
-0.049102783203125,
0.236572265625,
-0.72119140625,
-0.377197265625,
-0.2391357421875,
0.2452392578125,
-0.019805908203125,
0.79248046875,
0.53759765625,
0.1248779296875,
0.10791015625,
-0.5341796875,
-0.2108154296875,
0.41015625,
-0.12408447265625,
-0.... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are an experienced Codeforces user. Today you found out that during your activity on Codeforces you have made y submissions, out of which x have been successful. Thus, your current success rate on Codeforces is equal to x / y.
Your favorite rational number in the [0;1] range is p / q. Now you wonder: what is the smallest number of submissions you have to make if you want your success rate to be p / q?
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
Each of the next t lines contains four integers x, y, p and q (0 ≤ x ≤ y ≤ 109; 0 ≤ p ≤ q ≤ 109; y > 0; q > 0).
It is guaranteed that p / q is an irreducible fraction.
Hacks. For hacks, an additional constraint of t ≤ 5 must be met.
Output
For each test case, output a single integer equal to the smallest number of submissions you have to make if you want your success rate to be equal to your favorite rational number, or -1 if this is impossible to achieve.
Example
Input
4
3 10 1 2
7 14 3 8
20 70 2 7
5 6 1 1
Output
4
10
0
-1
Note
In the first example, you have to make 4 successful submissions. Your success rate will be equal to 7 / 14, or 1 / 2.
In the second example, you have to make 2 successful and 8 unsuccessful submissions. Your success rate will be equal to 9 / 24, or 3 / 8.
In the third example, there is no need to make any new submissions. Your success rate is already equal to 20 / 70, or 2 / 7.
In the fourth example, the only unsuccessful submission breaks your hopes of having the success rate equal to 1.
Submitted Solution:
```
def Ans(k):
x, y, p, q = k[0], k[1], k[2], k[3]
if (p/q == 1 and x != y) or (p == 0 and x!= 0):
print(-1)
elif p == 0 and x == 0:
print(0)
else:
up = 10**9
down = 1
dy = y-x
while (up > down + 1):
mid = (up+down)//2
## print(" up: " + str(up) + " mid: " + str(mid) + " down: " + str(down) )
qf = q*mid
pf = p*mid
dq = qf-pf
if( qf-y >= dq-dy and qf >= y and dq >= dy):
up = mid
else:
down = mid
if( q*down-y >= (q-p)*down-dy and q*down >= y and (q-p)*down >= dy):
print(q*down - y)
elif q*mid-y >= (q-p)*mid-dy and q*mid >= y and (q-p)*mid>=dy:
print(q*mid - y)
else:
print(q*up - y)
t = int( input() )
k = [0]*t
for i in range(t):
k[i] = list(map(int, input().split() ))
for i in range(t):
Ans(k[i])
```
Yes
| 50,166 | [
0.324951171875,
-0.141357421875,
-0.058807373046875,
0.23583984375,
-0.72314453125,
-0.394775390625,
-0.219970703125,
0.2418212890625,
0.043548583984375,
0.80419921875,
0.5146484375,
0.10272216796875,
0.11004638671875,
-0.51318359375,
-0.259521484375,
0.405517578125,
-0.1085815429687... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are an experienced Codeforces user. Today you found out that during your activity on Codeforces you have made y submissions, out of which x have been successful. Thus, your current success rate on Codeforces is equal to x / y.
Your favorite rational number in the [0;1] range is p / q. Now you wonder: what is the smallest number of submissions you have to make if you want your success rate to be p / q?
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
Each of the next t lines contains four integers x, y, p and q (0 ≤ x ≤ y ≤ 109; 0 ≤ p ≤ q ≤ 109; y > 0; q > 0).
It is guaranteed that p / q is an irreducible fraction.
Hacks. For hacks, an additional constraint of t ≤ 5 must be met.
Output
For each test case, output a single integer equal to the smallest number of submissions you have to make if you want your success rate to be equal to your favorite rational number, or -1 if this is impossible to achieve.
Example
Input
4
3 10 1 2
7 14 3 8
20 70 2 7
5 6 1 1
Output
4
10
0
-1
Note
In the first example, you have to make 4 successful submissions. Your success rate will be equal to 7 / 14, or 1 / 2.
In the second example, you have to make 2 successful and 8 unsuccessful submissions. Your success rate will be equal to 9 / 24, or 3 / 8.
In the third example, there is no need to make any new submissions. Your success rate is already equal to 20 / 70, or 2 / 7.
In the fourth example, the only unsuccessful submission breaks your hopes of having the success rate equal to 1.
Submitted Solution:
```
for _ in range(int(input())):
x,y,p,q=[int(x) for x in input().split(' ')]
if(y*p==x*q):
print(0)
continue
m1=-1
m2=-1
if(p==0):
m1=-1
else:
if(x%p):
m1=(x//p)+1
else:
m1=(x//p)
if(p==q):
m2=-1
else:
if((y-x)%(q-p)):
m2=((y-x)//(q-p))+1
else:
m2=((y-x)//(q-p))
if(m2==-1 or m1==-1):
print(-1)
else:
print(max(m1,m2)*q-y)
```
Yes
| 50,167 | [
0.29541015625,
-0.153076171875,
-0.0293731689453125,
0.2176513671875,
-0.705078125,
-0.39013671875,
-0.2362060546875,
0.2110595703125,
-0.0233917236328125,
0.798828125,
0.54541015625,
0.15576171875,
0.0810546875,
-0.5419921875,
-0.22119140625,
0.40869140625,
-0.10198974609375,
-0.6... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are an experienced Codeforces user. Today you found out that during your activity on Codeforces you have made y submissions, out of which x have been successful. Thus, your current success rate on Codeforces is equal to x / y.
Your favorite rational number in the [0;1] range is p / q. Now you wonder: what is the smallest number of submissions you have to make if you want your success rate to be p / q?
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
Each of the next t lines contains four integers x, y, p and q (0 ≤ x ≤ y ≤ 109; 0 ≤ p ≤ q ≤ 109; y > 0; q > 0).
It is guaranteed that p / q is an irreducible fraction.
Hacks. For hacks, an additional constraint of t ≤ 5 must be met.
Output
For each test case, output a single integer equal to the smallest number of submissions you have to make if you want your success rate to be equal to your favorite rational number, or -1 if this is impossible to achieve.
Example
Input
4
3 10 1 2
7 14 3 8
20 70 2 7
5 6 1 1
Output
4
10
0
-1
Note
In the first example, you have to make 4 successful submissions. Your success rate will be equal to 7 / 14, or 1 / 2.
In the second example, you have to make 2 successful and 8 unsuccessful submissions. Your success rate will be equal to 9 / 24, or 3 / 8.
In the third example, there is no need to make any new submissions. Your success rate is already equal to 20 / 70, or 2 / 7.
In the fourth example, the only unsuccessful submission breaks your hopes of having the success rate equal to 1.
Submitted Solution:
```
def gcd(a, b):
if a == 0:
return b
return gcd(b % a, a)
def get(x, y, p, q):
low, high, mid, best = 1, 1 << 65, 0, -1
while low <= high:
mid = (low + high + 1) >> 1
tp = p * mid
tq = q * mid
if tq >= y and x <= tp <= x + tq - y:
best = mid
high = mid - 1
else:
low = mid + 1
return best
T = int(input())
for _ in range(T):
x, y, p, q = map(int, input().split())
if x == 0 and p == q:
print(-1)
continue
if x == y and p == 0:
print(-1)
continue
if x == 0 and p == 0:
if y > q:
print(-1)
else:
print(q - y)
continue
nx, ny = x, y
nx //= gcd(x, y)
ny //= gcd(x, y)
#print("reduced", nx, ny)
need = get(nx, ny, p, q)
rx = need * p
ry = need * q
#print("first new", rx, ry)
low, high, mid, best = 0, 1 << 63, 0, -1
while low <= high:
mid = (low + high + 1) >> 1
if rx + mid * p >= x and ry + mid * q >= y and ry + mid * q - y >= rx + mid * p - x:
best = mid
high = mid - 1
else:
low = mid + 1
if best == -1:
print(-1)
continue
rx += best * p
ry += best * q
#print("resulting", rx, ry)
if rx * q == ry * p:
print(ry - y)
else:
print(-1)
```
No
| 50,168 | [
0.322265625,
-0.160400390625,
-0.0296478271484375,
0.265625,
-0.736328125,
-0.379638671875,
-0.2166748046875,
0.1923828125,
0.033905029296875,
0.7802734375,
0.51513671875,
0.0546875,
0.069580078125,
-0.5615234375,
-0.2247314453125,
0.449951171875,
-0.09857177734375,
-0.658203125,
... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are an experienced Codeforces user. Today you found out that during your activity on Codeforces you have made y submissions, out of which x have been successful. Thus, your current success rate on Codeforces is equal to x / y.
Your favorite rational number in the [0;1] range is p / q. Now you wonder: what is the smallest number of submissions you have to make if you want your success rate to be p / q?
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
Each of the next t lines contains four integers x, y, p and q (0 ≤ x ≤ y ≤ 109; 0 ≤ p ≤ q ≤ 109; y > 0; q > 0).
It is guaranteed that p / q is an irreducible fraction.
Hacks. For hacks, an additional constraint of t ≤ 5 must be met.
Output
For each test case, output a single integer equal to the smallest number of submissions you have to make if you want your success rate to be equal to your favorite rational number, or -1 if this is impossible to achieve.
Example
Input
4
3 10 1 2
7 14 3 8
20 70 2 7
5 6 1 1
Output
4
10
0
-1
Note
In the first example, you have to make 4 successful submissions. Your success rate will be equal to 7 / 14, or 1 / 2.
In the second example, you have to make 2 successful and 8 unsuccessful submissions. Your success rate will be equal to 9 / 24, or 3 / 8.
In the third example, there is no need to make any new submissions. Your success rate is already equal to 20 / 70, or 2 / 7.
In the fourth example, the only unsuccessful submission breaks your hopes of having the success rate equal to 1.
Submitted Solution:
```
t=int(input())
for l in range(t):
x,y,p,q=map(int,input().split())
if p==1 and q==1 or p==0 and x==0 :
c=0
else:
if p==1 and q==1 or p==0 :
c=-1
else:
if (x/y)>(p/q):
r=p
r2=q
m=q-(y%q)
y=(y+m)
p=p*(y//q)
q=q*(y//q)
if p>=x:
c=m
else:
if x%r==0:
z=(x-p)//r
else:
z=(x-p)//r+1
c=m+z*r2
else:
if (x/y)==(p/q):
c=0
else:
r=p
r2=q
m=q-(y%q)
x=x+m
y=(y+m)
p=p*(y//q)
q=q*(y//q)
if x>=p:
c=m
else:
if (p-x)%(r2-r)==0:
z=(p-x)//(r2-r)
else:
z=(p-x)//(r2-r)+1
c=m+z*r2
print(c)
```
No
| 50,169 | [
0.32421875,
-0.1260986328125,
-0.0335693359375,
0.242919921875,
-0.73681640625,
-0.39501953125,
-0.2462158203125,
0.238525390625,
-0.0292510986328125,
0.79296875,
0.5107421875,
0.15380859375,
0.09027099609375,
-0.51123046875,
-0.2421875,
0.43603515625,
-0.08197021484375,
-0.6494140... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are an experienced Codeforces user. Today you found out that during your activity on Codeforces you have made y submissions, out of which x have been successful. Thus, your current success rate on Codeforces is equal to x / y.
Your favorite rational number in the [0;1] range is p / q. Now you wonder: what is the smallest number of submissions you have to make if you want your success rate to be p / q?
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
Each of the next t lines contains four integers x, y, p and q (0 ≤ x ≤ y ≤ 109; 0 ≤ p ≤ q ≤ 109; y > 0; q > 0).
It is guaranteed that p / q is an irreducible fraction.
Hacks. For hacks, an additional constraint of t ≤ 5 must be met.
Output
For each test case, output a single integer equal to the smallest number of submissions you have to make if you want your success rate to be equal to your favorite rational number, or -1 if this is impossible to achieve.
Example
Input
4
3 10 1 2
7 14 3 8
20 70 2 7
5 6 1 1
Output
4
10
0
-1
Note
In the first example, you have to make 4 successful submissions. Your success rate will be equal to 7 / 14, or 1 / 2.
In the second example, you have to make 2 successful and 8 unsuccessful submissions. Your success rate will be equal to 9 / 24, or 3 / 8.
In the third example, there is no need to make any new submissions. Your success rate is already equal to 20 / 70, or 2 / 7.
In the fourth example, the only unsuccessful submission breaks your hopes of having the success rate equal to 1.
Submitted Solution:
```
def Ans(k):
x, y, p, q = k[0], k[1], k[2], k[3]
if p/q == x/y:
print(0)
elif p/q == 1 or p == 0:
print(-1)
else:
if x/y < p/q:
d1 = y-x
d2 = q-p
t = d1/d2
if t != int(t):
t = int(t+1)
else:
t = int(t)
print(int(t*q-y))
else:
t = x/p
if t != int(t):
t = int(t+1)
print(int( t*q - y ))
t = int( input() )
k = [0]*t
for i in range(t):
k[i] = list(map(int, input().split() ))
for i in range(t):
Ans(k[i])
```
No
| 50,170 | [
0.300048828125,
-0.125,
-0.062255859375,
0.2391357421875,
-0.7353515625,
-0.40478515625,
-0.2069091796875,
0.235595703125,
0.04473876953125,
0.80712890625,
0.50048828125,
0.1109619140625,
0.10162353515625,
-0.51123046875,
-0.265869140625,
0.415283203125,
-0.118896484375,
-0.6381835... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are an experienced Codeforces user. Today you found out that during your activity on Codeforces you have made y submissions, out of which x have been successful. Thus, your current success rate on Codeforces is equal to x / y.
Your favorite rational number in the [0;1] range is p / q. Now you wonder: what is the smallest number of submissions you have to make if you want your success rate to be p / q?
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
Each of the next t lines contains four integers x, y, p and q (0 ≤ x ≤ y ≤ 109; 0 ≤ p ≤ q ≤ 109; y > 0; q > 0).
It is guaranteed that p / q is an irreducible fraction.
Hacks. For hacks, an additional constraint of t ≤ 5 must be met.
Output
For each test case, output a single integer equal to the smallest number of submissions you have to make if you want your success rate to be equal to your favorite rational number, or -1 if this is impossible to achieve.
Example
Input
4
3 10 1 2
7 14 3 8
20 70 2 7
5 6 1 1
Output
4
10
0
-1
Note
In the first example, you have to make 4 successful submissions. Your success rate will be equal to 7 / 14, or 1 / 2.
In the second example, you have to make 2 successful and 8 unsuccessful submissions. Your success rate will be equal to 9 / 24, or 3 / 8.
In the third example, there is no need to make any new submissions. Your success rate is already equal to 20 / 70, or 2 / 7.
In the fourth example, the only unsuccessful submission breaks your hopes of having the success rate equal to 1.
Submitted Solution:
```
t=int(input())
for l in range(t):
x,y,p,q=map(int,input().split())
if p==1 and q==1 and x//y==1:
c=0
else:
if p==1 and q==1 or p==0:
c=-1
else:
if (x/y)>(p/q):
r=p
r2=q
m=q-(y%q)
if m==q:
m=0
y=(y+m)
p=p*(y//q)
q=q*(y//q)
if p>=x:
c=m
else:
if x%r==0:
z=(x-p)//r
else:
z=(x-p)//r+1
c=m+z*r2
else:
if (x/y)==(p/q):
c=0
else:
r=p
r2=q
m=q-(y%q)
if m==q:
m=0
x=x+m
y=(y+m)
p=p*(y//q)
q=q*(y//q)
if x>=p:
c=m
else:
if p%(r2-r)==0:
z=(p-x)//(r2-r)
else:
z=(p-x)//(r2-r)+1
c=m+z*r2
print(c)
```
No
| 50,171 | [
0.31884765625,
-0.1356201171875,
-0.02978515625,
0.236328125,
-0.75244140625,
-0.38720703125,
-0.2388916015625,
0.2445068359375,
-0.018585205078125,
0.794921875,
0.50634765625,
0.150390625,
0.08740234375,
-0.498046875,
-0.2452392578125,
0.44140625,
-0.08087158203125,
-0.63818359375... | 11 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi is participating in a programming contest, AXC001. He has just submitted his code to Problem A.
The problem has N test cases, all of which must be passed to get an AC verdict.
Takahashi's submission has passed M cases out of the N test cases.
Determine whether Takahashi's submission gets an AC.
Constraints
* 1 \leq N \leq 100
* 0 \leq M \leq N
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N M
Output
If Takahashi's submission gets an AC, print `Yes`; otherwise, print `No`.
Examples
Input
3 3
Output
Yes
Input
3 2
Output
No
Input
1 1
Output
Yes
"Correct Solution:
```
n,m=[i for i in input().split()]
print('Yes' if n==m else 'No')
```
| 50,282 | [
0.611328125,
0.2333984375,
-0.1800537109375,
-0.1458740234375,
-0.410888671875,
-0.308349609375,
0.214599609375,
-0.06158447265625,
0.13134765625,
1.07421875,
0.68603515625,
-0.07379150390625,
0.227783203125,
-1.08984375,
-0.54638671875,
-0.0560302734375,
-0.3076171875,
-0.40844726... | 11 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi is participating in a programming contest, AXC001. He has just submitted his code to Problem A.
The problem has N test cases, all of which must be passed to get an AC verdict.
Takahashi's submission has passed M cases out of the N test cases.
Determine whether Takahashi's submission gets an AC.
Constraints
* 1 \leq N \leq 100
* 0 \leq M \leq N
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N M
Output
If Takahashi's submission gets an AC, print `Yes`; otherwise, print `No`.
Examples
Input
3 3
Output
Yes
Input
3 2
Output
No
Input
1 1
Output
Yes
"Correct Solution:
```
n,m=input().split()
print("Yes" if n==m else "No")
```
| 50,283 | [
0.61962890625,
0.2509765625,
-0.1944580078125,
-0.129638671875,
-0.4404296875,
-0.345458984375,
0.2293701171875,
-0.01506805419921875,
0.13134765625,
1.068359375,
0.64697265625,
-0.043914794921875,
0.219970703125,
-1.07421875,
-0.509765625,
-0.056732177734375,
-0.2587890625,
-0.429... | 11 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi is participating in a programming contest, AXC001. He has just submitted his code to Problem A.
The problem has N test cases, all of which must be passed to get an AC verdict.
Takahashi's submission has passed M cases out of the N test cases.
Determine whether Takahashi's submission gets an AC.
Constraints
* 1 \leq N \leq 100
* 0 \leq M \leq N
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N M
Output
If Takahashi's submission gets an AC, print `Yes`; otherwise, print `No`.
Examples
Input
3 3
Output
Yes
Input
3 2
Output
No
Input
1 1
Output
Yes
"Correct Solution:
```
a,c = map(int,input().split())
print("Yes") if a==c else print("No")
```
| 50,284 | [
0.62060546875,
0.309326171875,
-0.154052734375,
-0.1302490234375,
-0.429443359375,
-0.299072265625,
0.162109375,
-0.0204010009765625,
0.040618896484375,
1.0458984375,
0.662109375,
-0.011077880859375,
0.263427734375,
-1.0849609375,
-0.482177734375,
-0.1251220703125,
-0.34521484375,
... | 11 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi is participating in a programming contest, AXC001. He has just submitted his code to Problem A.
The problem has N test cases, all of which must be passed to get an AC verdict.
Takahashi's submission has passed M cases out of the N test cases.
Determine whether Takahashi's submission gets an AC.
Constraints
* 1 \leq N \leq 100
* 0 \leq M \leq N
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N M
Output
If Takahashi's submission gets an AC, print `Yes`; otherwise, print `No`.
Examples
Input
3 3
Output
Yes
Input
3 2
Output
No
Input
1 1
Output
Yes
"Correct Solution:
```
N, M = map(int, input().split())
print('YNeos'[N!=M::2])
```
| 50,285 | [
0.60791015625,
0.304443359375,
-0.2275390625,
-0.142333984375,
-0.416748046875,
-0.228271484375,
0.11676025390625,
-0.01427459716796875,
0.1142578125,
1.0517578125,
0.6630859375,
-0.01543426513671875,
0.2890625,
-1.046875,
-0.439453125,
-0.0911865234375,
-0.323974609375,
-0.3688964... | 11 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi is participating in a programming contest, AXC001. He has just submitted his code to Problem A.
The problem has N test cases, all of which must be passed to get an AC verdict.
Takahashi's submission has passed M cases out of the N test cases.
Determine whether Takahashi's submission gets an AC.
Constraints
* 1 \leq N \leq 100
* 0 \leq M \leq N
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N M
Output
If Takahashi's submission gets an AC, print `Yes`; otherwise, print `No`.
Examples
Input
3 3
Output
Yes
Input
3 2
Output
No
Input
1 1
Output
Yes
"Correct Solution:
```
n,m=input().split();print('NYoe s'[n==m::2])
```
| 50,286 | [
0.615234375,
0.2259521484375,
-0.295654296875,
-0.06170654296875,
-0.59033203125,
-0.2286376953125,
0.168212890625,
-0.00444793701171875,
0.1824951171875,
1.0400390625,
0.55419921875,
0.0082244873046875,
0.24951171875,
-0.9658203125,
-0.52587890625,
0.02618408203125,
-0.289306640625,... | 11 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi is participating in a programming contest, AXC001. He has just submitted his code to Problem A.
The problem has N test cases, all of which must be passed to get an AC verdict.
Takahashi's submission has passed M cases out of the N test cases.
Determine whether Takahashi's submission gets an AC.
Constraints
* 1 \leq N \leq 100
* 0 \leq M \leq N
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N M
Output
If Takahashi's submission gets an AC, print `Yes`; otherwise, print `No`.
Examples
Input
3 3
Output
Yes
Input
3 2
Output
No
Input
1 1
Output
Yes
"Correct Solution:
```
a,o=map(int, input().split())
print("Yes" if a <= o else "No")
```
| 50,288 | [
0.5830078125,
0.287109375,
-0.25927734375,
-0.14306640625,
-0.435546875,
-0.356689453125,
0.1651611328125,
0.07623291015625,
0.1259765625,
1.0947265625,
0.6435546875,
-0.0285491943359375,
0.2347412109375,
-1.033203125,
-0.441650390625,
-0.06817626953125,
-0.30615234375,
-0.3125,
... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi is participating in a programming contest, AXC001. He has just submitted his code to Problem A.
The problem has N test cases, all of which must be passed to get an AC verdict.
Takahashi's submission has passed M cases out of the N test cases.
Determine whether Takahashi's submission gets an AC.
Constraints
* 1 \leq N \leq 100
* 0 \leq M \leq N
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N M
Output
If Takahashi's submission gets an AC, print `Yes`; otherwise, print `No`.
Examples
Input
3 3
Output
Yes
Input
3 2
Output
No
Input
1 1
Output
Yes
Submitted Solution:
```
# AC or WA
N, M = map(int, input().split())
print(['No', 'Yes'][N == M])
```
Yes
| 50,289 | [
0.60400390625,
0.23193359375,
-0.275146484375,
-0.06646728515625,
-0.420654296875,
-0.2032470703125,
0.0567626953125,
-0.02239990234375,
-0.01265716552734375,
1.0390625,
0.552734375,
0.0253143310546875,
0.206298828125,
-1.0302734375,
-0.414794921875,
-0.081787109375,
-0.214111328125,... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi is participating in a programming contest, AXC001. He has just submitted his code to Problem A.
The problem has N test cases, all of which must be passed to get an AC verdict.
Takahashi's submission has passed M cases out of the N test cases.
Determine whether Takahashi's submission gets an AC.
Constraints
* 1 \leq N \leq 100
* 0 \leq M \leq N
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N M
Output
If Takahashi's submission gets an AC, print `Yes`; otherwise, print `No`.
Examples
Input
3 3
Output
Yes
Input
3 2
Output
No
Input
1 1
Output
Yes
Submitted Solution:
```
n, m = map(int, input().split(' '))
print('Yes' if n == m else 'No')
```
Yes
| 50,290 | [
0.568359375,
0.2393798828125,
-0.295654296875,
-0.08990478515625,
-0.39892578125,
-0.1595458984375,
0.0771484375,
-0.043304443359375,
-0.006084442138671875,
1.064453125,
0.611328125,
0.04742431640625,
0.2349853515625,
-1.0419921875,
-0.444580078125,
-0.0616455078125,
-0.2059326171875... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi is participating in a programming contest, AXC001. He has just submitted his code to Problem A.
The problem has N test cases, all of which must be passed to get an AC verdict.
Takahashi's submission has passed M cases out of the N test cases.
Determine whether Takahashi's submission gets an AC.
Constraints
* 1 \leq N \leq 100
* 0 \leq M \leq N
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N M
Output
If Takahashi's submission gets an AC, print `Yes`; otherwise, print `No`.
Examples
Input
3 3
Output
Yes
Input
3 2
Output
No
Input
1 1
Output
Yes
Submitted Solution:
```
N, M = input().split(' ')
print('Yes' if N == M else 'No')
```
Yes
| 50,291 | [
0.6201171875,
0.1904296875,
-0.2626953125,
-0.0975341796875,
-0.44091796875,
-0.179931640625,
0.1607666015625,
-0.03948974609375,
0.0677490234375,
1.0361328125,
0.5869140625,
0.01151275634765625,
0.1292724609375,
-1.02734375,
-0.509765625,
-0.08795166015625,
-0.1849365234375,
-0.42... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi is participating in a programming contest, AXC001. He has just submitted his code to Problem A.
The problem has N test cases, all of which must be passed to get an AC verdict.
Takahashi's submission has passed M cases out of the N test cases.
Determine whether Takahashi's submission gets an AC.
Constraints
* 1 \leq N \leq 100
* 0 \leq M \leq N
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N M
Output
If Takahashi's submission gets an AC, print `Yes`; otherwise, print `No`.
Examples
Input
3 3
Output
Yes
Input
3 2
Output
No
Input
1 1
Output
Yes
Submitted Solution:
```
a,b = input().split(' ')
if a == b:
print('Yes')
else:
print('No')
```
Yes
| 50,292 | [
0.62939453125,
0.1756591796875,
-0.27392578125,
-0.076416015625,
-0.4873046875,
-0.2178955078125,
0.1558837890625,
-0.0162811279296875,
0.036651611328125,
1.0556640625,
0.52734375,
-0.03948974609375,
0.12200927734375,
-1.00390625,
-0.50634765625,
-0.10455322265625,
-0.1787109375,
-... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi is participating in a programming contest, AXC001. He has just submitted his code to Problem A.
The problem has N test cases, all of which must be passed to get an AC verdict.
Takahashi's submission has passed M cases out of the N test cases.
Determine whether Takahashi's submission gets an AC.
Constraints
* 1 \leq N \leq 100
* 0 \leq M \leq N
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N M
Output
If Takahashi's submission gets an AC, print `Yes`; otherwise, print `No`.
Examples
Input
3 3
Output
Yes
Input
3 2
Output
No
Input
1 1
Output
Yes
Submitted Solution:
```
input m;
input n;
if m=n:
print("yes")
else:
print("no")
```
No
| 50,293 | [
0.61181640625,
0.1590576171875,
-0.280029296875,
-0.018096923828125,
-0.40576171875,
-0.13525390625,
0.211181640625,
-0.07550048828125,
0.0562744140625,
0.97705078125,
0.64697265625,
-0.043487548828125,
0.1353759765625,
-0.97802734375,
-0.53125,
-0.07122802734375,
-0.2161865234375,
... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi is participating in a programming contest, AXC001. He has just submitted his code to Problem A.
The problem has N test cases, all of which must be passed to get an AC verdict.
Takahashi's submission has passed M cases out of the N test cases.
Determine whether Takahashi's submission gets an AC.
Constraints
* 1 \leq N \leq 100
* 0 \leq M \leq N
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N M
Output
If Takahashi's submission gets an AC, print `Yes`; otherwise, print `No`.
Examples
Input
3 3
Output
Yes
Input
3 2
Output
No
Input
1 1
Output
Yes
Submitted Solution:
```
n=input()
p=input()
p=p.split()
q=[]
for i in range(int(n)):
j=min(p[:i+1])
if j==p[i]:
q.append(p[i])
print(len(q))
```
No
| 50,294 | [
0.59765625,
0.1143798828125,
-0.134521484375,
0.0204010009765625,
-0.4814453125,
-0.2344970703125,
0.109130859375,
-0.0484619140625,
0.044464111328125,
1.0732421875,
0.5634765625,
-0.07904052734375,
-0.00731658935546875,
-0.99609375,
-0.59912109375,
-0.07794189453125,
-0.229858398437... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi is participating in a programming contest, AXC001. He has just submitted his code to Problem A.
The problem has N test cases, all of which must be passed to get an AC verdict.
Takahashi's submission has passed M cases out of the N test cases.
Determine whether Takahashi's submission gets an AC.
Constraints
* 1 \leq N \leq 100
* 0 \leq M \leq N
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N M
Output
If Takahashi's submission gets an AC, print `Yes`; otherwise, print `No`.
Examples
Input
3 3
Output
Yes
Input
3 2
Output
No
Input
1 1
Output
Yes
Submitted Solution:
```
n,m = map(int,input().split())
if n == m;
print(Yes)
else:
print(No)
```
No
| 50,295 | [
0.5556640625,
0.242919921875,
-0.30126953125,
-0.0869140625,
-0.383544921875,
-0.192626953125,
0.07745361328125,
-0.04638671875,
0.0003285408020019531,
1.056640625,
0.6083984375,
0.05438232421875,
0.217529296875,
-1.0517578125,
-0.437744140625,
-0.069091796875,
-0.1983642578125,
-0... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi is participating in a programming contest, AXC001. He has just submitted his code to Problem A.
The problem has N test cases, all of which must be passed to get an AC verdict.
Takahashi's submission has passed M cases out of the N test cases.
Determine whether Takahashi's submission gets an AC.
Constraints
* 1 \leq N \leq 100
* 0 \leq M \leq N
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N M
Output
If Takahashi's submission gets an AC, print `Yes`; otherwise, print `No`.
Examples
Input
3 3
Output
Yes
Input
3 2
Output
No
Input
1 1
Output
Yes
Submitted Solution:
```
a = input("A")
b = input("B")
sumA = ""
sumB = ""
for i in range(int(b)):
sumA +=""+str(a)
for i in range(int(a)):
sumB +=""+str(b)
if(int(sumA)>int(sumB)):
print(sumA)
elif(int(sumB)>int(sumA)):
print(sumB)
elif(int(sumA) == int(sumB)):
print(sumA)
```
No
| 50,296 | [
0.44921875,
0.002254486083984375,
-0.264404296875,
0.0086517333984375,
-0.45263671875,
-0.2325439453125,
0.1368408203125,
-0.007564544677734375,
-0.0001068115234375,
0.9345703125,
0.448974609375,
-0.1038818359375,
-0.003154754638671875,
-0.81884765625,
-0.56884765625,
-0.11920166015625... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
<image>
The International Clown and Pierrot Competition (ICPC), is one of the most distinguished and also the most popular events on earth in the show business.
One of the unique features of this contest is the great number of judges that sometimes counts up to one hundred. The number of judges may differ from one contestant to another, because judges with any relationship whatsoever with a specific contestant are temporarily excluded for scoring his/her performance.
Basically, scores given to a contestant's performance by the judges are averaged to decide his/her score. To avoid letting judges with eccentric viewpoints too much influence the score, the highest and the lowest scores are set aside in this calculation. If the same highest score is marked by two or more judges, only one of them is ignored. The same is with the lowest score. The average, which may contain fractions, are truncated down to obtain final score as an integer.
You are asked to write a program that computes the scores of performances, given the scores of all the judges, to speed up the event to be suited for a TV program.
Input
The input consists of a number of datasets, each corresponding to a contestant's performance. There are no more than 20 datasets in the input.
A dataset begins with a line with an integer n, the number of judges participated in scoring the performance (3 ≤ n ≤ 100). Each of the n lines following it has an integral score s (0 ≤ s ≤ 1000) marked by a judge. No other characters except for digits to express these numbers are in the input. Judges' names are kept secret.
The end of the input is indicated by a line with a single zero in it.
Output
For each dataset, a line containing a single decimal integer indicating the score for the corresponding performance should be output. No other characters should be on the output line.
Example
Input
3
1000
342
0
5
2
2
9
11
932
5
300
1000
0
200
400
8
353
242
402
274
283
132
402
523
0
Output
342
7
300
326
Submitted Solution:
```
while True:
n = int(input())
if n == 0:
break
data=[]
for i in range(n):
a=int(input())
data.append(a)
print((sum(data)-max(data)-min(data))//(n-2))
```
Yes
| 50,447 | [
0.1627197265625,
-0.2344970703125,
-0.0872802734375,
-0.0186767578125,
-0.4130859375,
-0.54541015625,
0.0091400146484375,
0.1448974609375,
-0.01018524169921875,
0.630859375,
0.564453125,
-0.39501953125,
0.1807861328125,
-1.1005859375,
-0.418212890625,
-0.0333251953125,
-0.693359375,
... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
<image>
The International Clown and Pierrot Competition (ICPC), is one of the most distinguished and also the most popular events on earth in the show business.
One of the unique features of this contest is the great number of judges that sometimes counts up to one hundred. The number of judges may differ from one contestant to another, because judges with any relationship whatsoever with a specific contestant are temporarily excluded for scoring his/her performance.
Basically, scores given to a contestant's performance by the judges are averaged to decide his/her score. To avoid letting judges with eccentric viewpoints too much influence the score, the highest and the lowest scores are set aside in this calculation. If the same highest score is marked by two or more judges, only one of them is ignored. The same is with the lowest score. The average, which may contain fractions, are truncated down to obtain final score as an integer.
You are asked to write a program that computes the scores of performances, given the scores of all the judges, to speed up the event to be suited for a TV program.
Input
The input consists of a number of datasets, each corresponding to a contestant's performance. There are no more than 20 datasets in the input.
A dataset begins with a line with an integer n, the number of judges participated in scoring the performance (3 ≤ n ≤ 100). Each of the n lines following it has an integral score s (0 ≤ s ≤ 1000) marked by a judge. No other characters except for digits to express these numbers are in the input. Judges' names are kept secret.
The end of the input is indicated by a line with a single zero in it.
Output
For each dataset, a line containing a single decimal integer indicating the score for the corresponding performance should be output. No other characters should be on the output line.
Example
Input
3
1000
342
0
5
2
2
9
11
932
5
300
1000
0
200
400
8
353
242
402
274
283
132
402
523
0
Output
342
7
300
326
Submitted Solution:
```
import math
while True:
n = int(input())
scores = [int(input()) for i in range(n)]
scores.sort()
if n == 0:
break
total = 0
for i in range(1, n - 1):
total += scores[i]
print(math.floor(total / (n - 2)))
```
Yes
| 50,448 | [
0.17626953125,
-0.218017578125,
-0.1068115234375,
-0.017333984375,
-0.41015625,
-0.53076171875,
-0.00470733642578125,
0.1630859375,
-0.0005688667297363281,
0.66748046875,
0.55517578125,
-0.41015625,
0.1912841796875,
-1.09375,
-0.429931640625,
0.0011844635009765625,
-0.67822265625,
... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
<image>
The International Clown and Pierrot Competition (ICPC), is one of the most distinguished and also the most popular events on earth in the show business.
One of the unique features of this contest is the great number of judges that sometimes counts up to one hundred. The number of judges may differ from one contestant to another, because judges with any relationship whatsoever with a specific contestant are temporarily excluded for scoring his/her performance.
Basically, scores given to a contestant's performance by the judges are averaged to decide his/her score. To avoid letting judges with eccentric viewpoints too much influence the score, the highest and the lowest scores are set aside in this calculation. If the same highest score is marked by two or more judges, only one of them is ignored. The same is with the lowest score. The average, which may contain fractions, are truncated down to obtain final score as an integer.
You are asked to write a program that computes the scores of performances, given the scores of all the judges, to speed up the event to be suited for a TV program.
Input
The input consists of a number of datasets, each corresponding to a contestant's performance. There are no more than 20 datasets in the input.
A dataset begins with a line with an integer n, the number of judges participated in scoring the performance (3 ≤ n ≤ 100). Each of the n lines following it has an integral score s (0 ≤ s ≤ 1000) marked by a judge. No other characters except for digits to express these numbers are in the input. Judges' names are kept secret.
The end of the input is indicated by a line with a single zero in it.
Output
For each dataset, a line containing a single decimal integer indicating the score for the corresponding performance should be output. No other characters should be on the output line.
Example
Input
3
1000
342
0
5
2
2
9
11
932
5
300
1000
0
200
400
8
353
242
402
274
283
132
402
523
0
Output
342
7
300
326
Submitted Solution:
```
# coding: utf-8
# Your code here!
while(1):
risuto = []
num = int(input())
if num == 0 :
break
for i in range(num):
risuto.append(int(input()))
print((sum(risuto)-max(risuto)-min(risuto))//(num-2))
```
Yes
| 50,449 | [
0.2108154296875,
-0.2301025390625,
-0.1805419921875,
0.0130615234375,
-0.427001953125,
-0.58642578125,
-0.04498291015625,
0.1749267578125,
0.10162353515625,
0.64013671875,
0.57275390625,
-0.351318359375,
0.195068359375,
-0.97607421875,
-0.3623046875,
-0.01494598388671875,
-0.66650390... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
<image>
The International Clown and Pierrot Competition (ICPC), is one of the most distinguished and also the most popular events on earth in the show business.
One of the unique features of this contest is the great number of judges that sometimes counts up to one hundred. The number of judges may differ from one contestant to another, because judges with any relationship whatsoever with a specific contestant are temporarily excluded for scoring his/her performance.
Basically, scores given to a contestant's performance by the judges are averaged to decide his/her score. To avoid letting judges with eccentric viewpoints too much influence the score, the highest and the lowest scores are set aside in this calculation. If the same highest score is marked by two or more judges, only one of them is ignored. The same is with the lowest score. The average, which may contain fractions, are truncated down to obtain final score as an integer.
You are asked to write a program that computes the scores of performances, given the scores of all the judges, to speed up the event to be suited for a TV program.
Input
The input consists of a number of datasets, each corresponding to a contestant's performance. There are no more than 20 datasets in the input.
A dataset begins with a line with an integer n, the number of judges participated in scoring the performance (3 ≤ n ≤ 100). Each of the n lines following it has an integral score s (0 ≤ s ≤ 1000) marked by a judge. No other characters except for digits to express these numbers are in the input. Judges' names are kept secret.
The end of the input is indicated by a line with a single zero in it.
Output
For each dataset, a line containing a single decimal integer indicating the score for the corresponding performance should be output. No other characters should be on the output line.
Example
Input
3
1000
342
0
5
2
2
9
11
932
5
300
1000
0
200
400
8
353
242
402
274
283
132
402
523
0
Output
342
7
300
326
Submitted Solution:
```
def main():
N = int(input())
while N != 0:
s = [int(input()) for i in range(N)]
s.sort()
print(sum(s[1:N-1])//(N-2))
N = int(input())
if __name__ == '__main__':
main()
```
Yes
| 50,450 | [
0.16015625,
-0.21240234375,
-0.110595703125,
-0.03338623046875,
-0.40673828125,
-0.53515625,
0.0014715194702148438,
0.1551513671875,
-0.02606201171875,
0.59765625,
0.57080078125,
-0.4296875,
0.190185546875,
-1.111328125,
-0.433837890625,
-0.0271453857421875,
-0.69482421875,
-0.8818... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
<image>
The International Clown and Pierrot Competition (ICPC), is one of the most distinguished and also the most popular events on earth in the show business.
One of the unique features of this contest is the great number of judges that sometimes counts up to one hundred. The number of judges may differ from one contestant to another, because judges with any relationship whatsoever with a specific contestant are temporarily excluded for scoring his/her performance.
Basically, scores given to a contestant's performance by the judges are averaged to decide his/her score. To avoid letting judges with eccentric viewpoints too much influence the score, the highest and the lowest scores are set aside in this calculation. If the same highest score is marked by two or more judges, only one of them is ignored. The same is with the lowest score. The average, which may contain fractions, are truncated down to obtain final score as an integer.
You are asked to write a program that computes the scores of performances, given the scores of all the judges, to speed up the event to be suited for a TV program.
Input
The input consists of a number of datasets, each corresponding to a contestant's performance. There are no more than 20 datasets in the input.
A dataset begins with a line with an integer n, the number of judges participated in scoring the performance (3 ≤ n ≤ 100). Each of the n lines following it has an integral score s (0 ≤ s ≤ 1000) marked by a judge. No other characters except for digits to express these numbers are in the input. Judges' names are kept secret.
The end of the input is indicated by a line with a single zero in it.
Output
For each dataset, a line containing a single decimal integer indicating the score for the corresponding performance should be output. No other characters should be on the output line.
Example
Input
3
1000
342
0
5
2
2
9
11
932
5
300
1000
0
200
400
8
353
242
402
274
283
132
402
523
0
Output
342
7
300
326
Submitted Solution:
```
import math
def main():
r = []
while True:
n = int(input())
if n == 0:
break
m = []
for i in range(n):
m.append(int(input()))
r.append(math.floor((sum(m) - max(m) - min(m)/(n-2))))
res = ''
for j in r:
res += str(j)
print(res)
main()
```
No
| 50,451 | [
0.1739501953125,
-0.217041015625,
-0.0894775390625,
-0.04205322265625,
-0.421630859375,
-0.525390625,
0.00969696044921875,
0.1519775390625,
-0.018798828125,
0.62890625,
0.5673828125,
-0.410888671875,
0.2000732421875,
-1.0703125,
-0.4150390625,
-0.0101165771484375,
-0.67822265625,
-... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
<image>
The International Clown and Pierrot Competition (ICPC), is one of the most distinguished and also the most popular events on earth in the show business.
One of the unique features of this contest is the great number of judges that sometimes counts up to one hundred. The number of judges may differ from one contestant to another, because judges with any relationship whatsoever with a specific contestant are temporarily excluded for scoring his/her performance.
Basically, scores given to a contestant's performance by the judges are averaged to decide his/her score. To avoid letting judges with eccentric viewpoints too much influence the score, the highest and the lowest scores are set aside in this calculation. If the same highest score is marked by two or more judges, only one of them is ignored. The same is with the lowest score. The average, which may contain fractions, are truncated down to obtain final score as an integer.
You are asked to write a program that computes the scores of performances, given the scores of all the judges, to speed up the event to be suited for a TV program.
Input
The input consists of a number of datasets, each corresponding to a contestant's performance. There are no more than 20 datasets in the input.
A dataset begins with a line with an integer n, the number of judges participated in scoring the performance (3 ≤ n ≤ 100). Each of the n lines following it has an integral score s (0 ≤ s ≤ 1000) marked by a judge. No other characters except for digits to express these numbers are in the input. Judges' names are kept secret.
The end of the input is indicated by a line with a single zero in it.
Output
For each dataset, a line containing a single decimal integer indicating the score for the corresponding performance should be output. No other characters should be on the output line.
Example
Input
3
1000
342
0
5
2
2
9
11
932
5
300
1000
0
200
400
8
353
242
402
274
283
132
402
523
0
Output
342
7
300
326
Submitted Solution:
```
j = 0
lists = []
flag = 0
cnt = 0
while 1:
n = int(input())
if n == 0:
break
for i in range(n):
s = int(input())
lists.append(s)
for i in range(n):
if lists[i] == max(lists):
flag += 1
pass
elif lists[i] == min(lists):
flag += 1
pass
else:
cnt += lists[i]
if flag >= 2:
n -= 2
print(cnt // n)
```
No
| 50,452 | [
0.16650390625,
-0.237060546875,
-0.0699462890625,
-0.010894775390625,
-0.432373046875,
-0.56201171875,
-0.031463623046875,
0.159423828125,
-0.041229248046875,
0.64501953125,
0.57568359375,
-0.364990234375,
0.190185546875,
-1.09765625,
-0.397705078125,
0.00971221923828125,
-0.67626953... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
<image>
The International Clown and Pierrot Competition (ICPC), is one of the most distinguished and also the most popular events on earth in the show business.
One of the unique features of this contest is the great number of judges that sometimes counts up to one hundred. The number of judges may differ from one contestant to another, because judges with any relationship whatsoever with a specific contestant are temporarily excluded for scoring his/her performance.
Basically, scores given to a contestant's performance by the judges are averaged to decide his/her score. To avoid letting judges with eccentric viewpoints too much influence the score, the highest and the lowest scores are set aside in this calculation. If the same highest score is marked by two or more judges, only one of them is ignored. The same is with the lowest score. The average, which may contain fractions, are truncated down to obtain final score as an integer.
You are asked to write a program that computes the scores of performances, given the scores of all the judges, to speed up the event to be suited for a TV program.
Input
The input consists of a number of datasets, each corresponding to a contestant's performance. There are no more than 20 datasets in the input.
A dataset begins with a line with an integer n, the number of judges participated in scoring the performance (3 ≤ n ≤ 100). Each of the n lines following it has an integral score s (0 ≤ s ≤ 1000) marked by a judge. No other characters except for digits to express these numbers are in the input. Judges' names are kept secret.
The end of the input is indicated by a line with a single zero in it.
Output
For each dataset, a line containing a single decimal integer indicating the score for the corresponding performance should be output. No other characters should be on the output line.
Example
Input
3
1000
342
0
5
2
2
9
11
932
5
300
1000
0
200
400
8
353
242
402
274
283
132
402
523
0
Output
342
7
300
326
Submitted Solution:
```
import sys
while True:
n = int(sys.stdin.readline().rstrip())
if n == 0:
break
scores = [int(sys.stdin.readline().rstrip()) for i in range(n)]
result = (sum(scores) - (min(scores) + max(scores)) // n - 2)
print(result)
```
No
| 50,453 | [
0.1685791015625,
-0.236572265625,
-0.056732177734375,
-0.0196533203125,
-0.404296875,
-0.55224609375,
-0.014129638671875,
0.0814208984375,
-0.03680419921875,
0.64892578125,
0.53662109375,
-0.442626953125,
0.189208984375,
-1.06640625,
-0.403076171875,
-0.0132293701171875,
-0.657226562... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
<image>
The International Clown and Pierrot Competition (ICPC), is one of the most distinguished and also the most popular events on earth in the show business.
One of the unique features of this contest is the great number of judges that sometimes counts up to one hundred. The number of judges may differ from one contestant to another, because judges with any relationship whatsoever with a specific contestant are temporarily excluded for scoring his/her performance.
Basically, scores given to a contestant's performance by the judges are averaged to decide his/her score. To avoid letting judges with eccentric viewpoints too much influence the score, the highest and the lowest scores are set aside in this calculation. If the same highest score is marked by two or more judges, only one of them is ignored. The same is with the lowest score. The average, which may contain fractions, are truncated down to obtain final score as an integer.
You are asked to write a program that computes the scores of performances, given the scores of all the judges, to speed up the event to be suited for a TV program.
Input
The input consists of a number of datasets, each corresponding to a contestant's performance. There are no more than 20 datasets in the input.
A dataset begins with a line with an integer n, the number of judges participated in scoring the performance (3 ≤ n ≤ 100). Each of the n lines following it has an integral score s (0 ≤ s ≤ 1000) marked by a judge. No other characters except for digits to express these numbers are in the input. Judges' names are kept secret.
The end of the input is indicated by a line with a single zero in it.
Output
For each dataset, a line containing a single decimal integer indicating the score for the corresponding performance should be output. No other characters should be on the output line.
Example
Input
3
1000
342
0
5
2
2
9
11
932
5
300
1000
0
200
400
8
353
242
402
274
283
132
402
523
0
Output
342
7
300
326
Submitted Solution:
```
while True:
n = int(input())
if n == 0:
exit()
score = []
for i in range(n):
score.append(int(input()))
print(sum(sorted(score)[1:-1]))
```
No
| 50,454 | [
0.178466796875,
-0.2021484375,
-0.124755859375,
0.0085906982421875,
-0.38427734375,
-0.5576171875,
0.0121917724609375,
0.15966796875,
-0.0172271728515625,
0.60205078125,
0.5791015625,
-0.42333984375,
0.182373046875,
-1.1142578125,
-0.4462890625,
-0.030303955078125,
-0.69140625,
-0.... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a mysterious language (codenamed "Secret") available in "Custom Test" tab. Find out what this language is and write a program which outputs its name. Note that the program must be written in this language.
Input
This program has only one test, and it's empty (it doesn't give your program anything to read).
Output
Output the name of the mysterious language.
Examples
Submitted Solution:
```
print("Python3")
```
No
| 50,757 | [
0.50048828125,
-0.304443359375,
-0.38330078125,
-0.0296478271484375,
-0.453369140625,
-0.347900390625,
-0.12353515625,
0.45654296875,
-0.2587890625,
0.55322265625,
0.494873046875,
0.202880859375,
0.07794189453125,
-0.71875,
-0.61279296875,
-0.1334228515625,
-0.1688232421875,
-0.738... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a mysterious language (codenamed "Secret") available in "Custom Test" tab. Find out what this language is and write a program which outputs its name. Note that the program must be written in this language.
Input
This program has only one test, and it's empty (it doesn't give your program anything to read).
Output
Output the name of the mysterious language.
Examples
Submitted Solution:
```
print("Python")
```
No
| 50,759 | [
0.48046875,
-0.30712890625,
-0.412841796875,
-0.0302886962890625,
-0.458740234375,
-0.3701171875,
-0.1158447265625,
0.462646484375,
-0.251953125,
0.55712890625,
0.50830078125,
0.2193603515625,
0.0848388671875,
-0.69189453125,
-0.6083984375,
-0.10125732421875,
-0.1744384765625,
-0.7... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
N friends of Takahashi has come to a theme park.
To ride the most popular roller coaster in the park, you must be at least K centimeters tall.
The i-th friend is h_i centimeters tall.
How many of the Takahashi's friends can ride the roller coaster?
Constraints
* 1 \le N \le 10^5
* 1 \le K \le 500
* 1 \le h_i \le 500
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N K
h_1 h_2 \ldots h_N
Output
Print the number of people among the Takahashi's friends who can ride the roller coaster.
Examples
Input
4 150
150 140 100 200
Output
2
Input
1 500
499
Output
0
Input
5 1
100 200 300 400 500
Output
5
Submitted Solution:
```
N, K = map(int, input().split())
print(sum([int(i) >= K for i in input().split()]))
```
Yes
| 51,099 | [
0.6455078125,
0.1842041015625,
0.07269287109375,
0.267333984375,
-0.306884765625,
-0.271484375,
0.0003476142883300781,
0.332763671875,
-0.01113128662109375,
0.56884765625,
0.268798828125,
-0.1744384765625,
0.1278076171875,
-0.5546875,
-0.429443359375,
0.362060546875,
-0.94921875,
-... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
N friends of Takahashi has come to a theme park.
To ride the most popular roller coaster in the park, you must be at least K centimeters tall.
The i-th friend is h_i centimeters tall.
How many of the Takahashi's friends can ride the roller coaster?
Constraints
* 1 \le N \le 10^5
* 1 \le K \le 500
* 1 \le h_i \le 500
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N K
h_1 h_2 \ldots h_N
Output
Print the number of people among the Takahashi's friends who can ride the roller coaster.
Examples
Input
4 150
150 140 100 200
Output
2
Input
1 500
499
Output
0
Input
5 1
100 200 300 400 500
Output
5
Submitted Solution:
```
N,K=map(int,input().split())
h=list(map(int,input().split()))
print(sum(x>=K for x in h))
```
Yes
| 51,102 | [
0.62744140625,
0.183349609375,
0.09149169921875,
0.267333984375,
-0.3193359375,
-0.25634765625,
-0.0306243896484375,
0.348876953125,
-0.007396697998046875,
0.61328125,
0.277099609375,
-0.129150390625,
0.1962890625,
-0.5537109375,
-0.411865234375,
0.3837890625,
-0.9326171875,
-0.855... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
N friends of Takahashi has come to a theme park.
To ride the most popular roller coaster in the park, you must be at least K centimeters tall.
The i-th friend is h_i centimeters tall.
How many of the Takahashi's friends can ride the roller coaster?
Constraints
* 1 \le N \le 10^5
* 1 \le K \le 500
* 1 \le h_i \le 500
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N K
h_1 h_2 \ldots h_N
Output
Print the number of people among the Takahashi's friends who can ride the roller coaster.
Examples
Input
4 150
150 140 100 200
Output
2
Input
1 500
499
Output
0
Input
5 1
100 200 300 400 500
Output
5
Submitted Solution:
```
N_K = str(input())
H = str(input()).split(" ")
N = N_K.split(" ")[0]
K = N_K.split(" ")[1]
count = 0
for h in H:
if K <= h:
count += 1
print(count)
```
No
| 51,105 | [
0.59814453125,
0.12841796875,
0.1722412109375,
0.272216796875,
-0.40185546875,
-0.305908203125,
0.0244293212890625,
0.329833984375,
-0.0307769775390625,
0.626953125,
0.282958984375,
-0.2208251953125,
0.128662109375,
-0.57275390625,
-0.4287109375,
0.392333984375,
-0.958984375,
-0.90... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
«Polygon» is a system which allows to create programming tasks in a simple and professional way. When you add a test to the problem, the corresponding form asks you for the test index. As in most cases it is clear which index the next test will have, the system suggests the default value of the index. It is calculated as the smallest positive integer which is not used as an index for some previously added test.
You are to implement this feature. Create a program which determines the default index of the next test, given the indexes of the previously added tests.
Input
The first line contains one integer n (1 ≤ n ≤ 3000) — the amount of previously added tests. The second line contains n distinct integers a1, a2, ..., an (1 ≤ ai ≤ 3000) — indexes of these tests.
Output
Output the required default value for the next test index.
Examples
Input
3
1 7 2
Output
3
Submitted Solution:
```
count = int(input())
numbers = list(map(lambda x: int(x), input().split(' ')))
num = 1
while True:
if num in numbers:
pass
else:
print(num)
break
num += 1
```
Yes
| 51,630 | [
0.05438232421875,
0.199462890625,
-0.08642578125,
-0.11962890625,
-0.8251953125,
-0.1524658203125,
-0.01229095458984375,
0.146484375,
0.1365966796875,
0.85302734375,
0.5263671875,
-0.159912109375,
0.228271484375,
-0.70556640625,
-0.69091796875,
-0.004405975341796875,
-0.79296875,
-... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
«Polygon» is a system which allows to create programming tasks in a simple and professional way. When you add a test to the problem, the corresponding form asks you for the test index. As in most cases it is clear which index the next test will have, the system suggests the default value of the index. It is calculated as the smallest positive integer which is not used as an index for some previously added test.
You are to implement this feature. Create a program which determines the default index of the next test, given the indexes of the previously added tests.
Input
The first line contains one integer n (1 ≤ n ≤ 3000) — the amount of previously added tests. The second line contains n distinct integers a1, a2, ..., an (1 ≤ ai ≤ 3000) — indexes of these tests.
Output
Output the required default value for the next test index.
Examples
Input
3
1 7 2
Output
3
Submitted Solution:
```
from collections import Counter
n=int(input())
l=list(map(int,input().split()))
l1=[0]*3002
l1[0]=1
for i in range(n):
l1[l[i]]=1
print(l1.index(0))
```
Yes
| 51,631 | [
0.032257080078125,
0.181884765625,
-0.041412353515625,
-0.11737060546875,
-0.85400390625,
-0.11688232421875,
0.00213623046875,
0.1292724609375,
0.133056640625,
0.8115234375,
0.4765625,
-0.15576171875,
0.230224609375,
-0.763671875,
-0.71923828125,
0.0178680419921875,
-0.8076171875,
... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
«Polygon» is a system which allows to create programming tasks in a simple and professional way. When you add a test to the problem, the corresponding form asks you for the test index. As in most cases it is clear which index the next test will have, the system suggests the default value of the index. It is calculated as the smallest positive integer which is not used as an index for some previously added test.
You are to implement this feature. Create a program which determines the default index of the next test, given the indexes of the previously added tests.
Input
The first line contains one integer n (1 ≤ n ≤ 3000) — the amount of previously added tests. The second line contains n distinct integers a1, a2, ..., an (1 ≤ ai ≤ 3000) — indexes of these tests.
Output
Output the required default value for the next test index.
Examples
Input
3
1 7 2
Output
3
Submitted Solution:
```
n = int(input()); i = 1; x = sorted(list(map(int, input().split())))
while i in x: i+=1
print(i)
```
Yes
| 51,632 | [
0.043121337890625,
0.1234130859375,
-0.0338134765625,
-0.1177978515625,
-0.794921875,
-0.07452392578125,
-0.0298309326171875,
0.1884765625,
0.08709716796875,
0.83447265625,
0.529296875,
-0.206298828125,
0.23486328125,
-0.77880859375,
-0.66162109375,
0.0027294158935546875,
-0.78417968... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
«Polygon» is a system which allows to create programming tasks in a simple and professional way. When you add a test to the problem, the corresponding form asks you for the test index. As in most cases it is clear which index the next test will have, the system suggests the default value of the index. It is calculated as the smallest positive integer which is not used as an index for some previously added test.
You are to implement this feature. Create a program which determines the default index of the next test, given the indexes of the previously added tests.
Input
The first line contains one integer n (1 ≤ n ≤ 3000) — the amount of previously added tests. The second line contains n distinct integers a1, a2, ..., an (1 ≤ ai ≤ 3000) — indexes of these tests.
Output
Output the required default value for the next test index.
Examples
Input
3
1 7 2
Output
3
Submitted Solution:
```
n = int(input())
ll = list(map(int , input().split()))
minn = 1
while minn in ll:
minn += 1
print(minn)
```
Yes
| 51,633 | [
0.048858642578125,
0.2332763671875,
-0.0709228515625,
-0.056121826171875,
-0.84765625,
-0.11517333984375,
0.056640625,
0.1405029296875,
0.07177734375,
0.8359375,
0.60791015625,
-0.10784912109375,
0.26416015625,
-0.822265625,
-0.69140625,
0.0291900634765625,
-0.7880859375,
-0.493896... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
«Polygon» is a system which allows to create programming tasks in a simple and professional way. When you add a test to the problem, the corresponding form asks you for the test index. As in most cases it is clear which index the next test will have, the system suggests the default value of the index. It is calculated as the smallest positive integer which is not used as an index for some previously added test.
You are to implement this feature. Create a program which determines the default index of the next test, given the indexes of the previously added tests.
Input
The first line contains one integer n (1 ≤ n ≤ 3000) — the amount of previously added tests. The second line contains n distinct integers a1, a2, ..., an (1 ≤ ai ≤ 3000) — indexes of these tests.
Output
Output the required default value for the next test index.
Examples
Input
3
1 7 2
Output
3
Submitted Solution:
```
n=int(input())
a=sorted(list(map(int,input().split())))+[3001]
for i in range(n):
if a[i+1]-a[i]>1:
print(a[i]+1)
exit()
```
No
| 51,634 | [
0.03607177734375,
0.10833740234375,
-0.0333251953125,
-0.0850830078125,
-0.80126953125,
-0.08282470703125,
0.006381988525390625,
0.19921875,
0.076904296875,
0.85986328125,
0.52734375,
-0.254150390625,
0.199462890625,
-0.8212890625,
-0.6884765625,
-0.0310821533203125,
-0.79296875,
-... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
«Polygon» is a system which allows to create programming tasks in a simple and professional way. When you add a test to the problem, the corresponding form asks you for the test index. As in most cases it is clear which index the next test will have, the system suggests the default value of the index. It is calculated as the smallest positive integer which is not used as an index for some previously added test.
You are to implement this feature. Create a program which determines the default index of the next test, given the indexes of the previously added tests.
Input
The first line contains one integer n (1 ≤ n ≤ 3000) — the amount of previously added tests. The second line contains n distinct integers a1, a2, ..., an (1 ≤ ai ≤ 3000) — indexes of these tests.
Output
Output the required default value for the next test index.
Examples
Input
3
1 7 2
Output
3
Submitted Solution:
```
n = int(input())
a = input().split(" ")
for i in range(n):
a[i] = int(a[i])
a = sorted(a)
for i in range(n):
if a[i] != i+1:
break
print(i+1)
```
No
| 51,635 | [
0.017669677734375,
0.12841796875,
-0.0252227783203125,
-0.12158203125,
-0.81494140625,
-0.115966796875,
0.035400390625,
0.1610107421875,
0.0806884765625,
0.83056640625,
0.53759765625,
-0.2369384765625,
0.1666259765625,
-0.81494140625,
-0.673828125,
-0.0266265869140625,
-0.794921875,
... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
«Polygon» is a system which allows to create programming tasks in a simple and professional way. When you add a test to the problem, the corresponding form asks you for the test index. As in most cases it is clear which index the next test will have, the system suggests the default value of the index. It is calculated as the smallest positive integer which is not used as an index for some previously added test.
You are to implement this feature. Create a program which determines the default index of the next test, given the indexes of the previously added tests.
Input
The first line contains one integer n (1 ≤ n ≤ 3000) — the amount of previously added tests. The second line contains n distinct integers a1, a2, ..., an (1 ≤ ai ≤ 3000) — indexes of these tests.
Output
Output the required default value for the next test index.
Examples
Input
3
1 7 2
Output
3
Submitted Solution:
```
import sys
#считывание данных
n = int(sys.stdin.readline().strip('\n'))
an_raw = ((sys.stdin.readline().strip('\n')).split())
an = list(map(int,an_raw))
an_sorted=sorted(an)
i = 1
flag ='down'
if an_sorted[0] >= 2:
print(1)
flag ='end'
if (n >= 2)and(flag =='down'):
while i < n:
if (an_sorted[i] - an_sorted[i-1]) >= 2:
print(an_sorted[i-1]+1)
flag ='up'
i =i+1
if flag == 'down':
print(an_sorted[n-1]+1)
```
No
| 51,636 | [
-0.037506103515625,
-0.0008873939514160156,
0.0158538818359375,
-0.06658935546875,
-0.828125,
-0.09552001953125,
0.0733642578125,
0.170654296875,
0.08984375,
0.8798828125,
0.5732421875,
-0.376953125,
0.338623046875,
-0.77587890625,
-0.6552734375,
-0.0816650390625,
-0.9091796875,
-0... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
«Polygon» is a system which allows to create programming tasks in a simple and professional way. When you add a test to the problem, the corresponding form asks you for the test index. As in most cases it is clear which index the next test will have, the system suggests the default value of the index. It is calculated as the smallest positive integer which is not used as an index for some previously added test.
You are to implement this feature. Create a program which determines the default index of the next test, given the indexes of the previously added tests.
Input
The first line contains one integer n (1 ≤ n ≤ 3000) — the amount of previously added tests. The second line contains n distinct integers a1, a2, ..., an (1 ≤ ai ≤ 3000) — indexes of these tests.
Output
Output the required default value for the next test index.
Examples
Input
3
1 7 2
Output
3
Submitted Solution:
```
import math
t=int(input())
l=list(map(int,input().split()))
if(t<=2):
print(t+1)
else:
print(t)
```
No
| 51,637 | [
0.032928466796875,
0.22509765625,
-0.06024169921875,
-0.1483154296875,
-0.8359375,
-0.076904296875,
0.046539306640625,
0.170654296875,
0.07403564453125,
0.82958984375,
0.54052734375,
-0.1505126953125,
0.2264404296875,
-0.78125,
-0.68115234375,
0.01068115234375,
-0.771484375,
-0.500... | 11 |
Provide tags and a correct Python 3 solution for this coding contest problem.
While resting on the ship after the "Russian Code Cup" a boy named Misha invented an interesting game. He promised to give his quadrocopter to whoever will be the first one to make a rectangular table of size n × m, consisting of positive integers such that the sum of the squares of numbers for each row and each column was also a square.
Since checking the correctness of the table manually is difficult, Misha asks you to make each number in the table to not exceed 108.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 100) — the size of the table.
Output
Print the table that meets the condition: n lines containing m integers, separated by spaces. If there are multiple possible answers, you are allowed to print anyone. It is guaranteed that there exists at least one correct answer.
Examples
Input
1 1
Output
1
Input
1 2
Output
3 4
Tags: constructive algorithms, math, probabilities
Correct Solution:
```
"""
Codeforces Round 241 Div 1 Problem E
Author : chaotic_iak
Language: Python 3.3.4
"""
class InputHandlerObject(object):
inputs = []
def getInput(self, n = 0):
res = ""
inputs = self.inputs
if not inputs: inputs.extend(input().split(" "))
if n == 0:
res = inputs[:]
inputs[:] = []
while n > len(inputs):
inputs.extend(input().split(" "))
if n > 0:
res = inputs[:n]
inputs[:n] = []
return res
InputHandler = InputHandlerObject()
g = InputHandler.getInput
############################## SOLUTION ##############################
n,m = [int(x) for x in g()]
def sqr(n):
if n == 1:
return [1]
if n == 2:
return [4,3]
if n % 2:
return [(n+1)//2, 2] + [1] * (n-2)
return [(n-2)//2] + [1] * (n-1)
a = sqr(n)
b = sqr(m)
for i in range(n):
res = [str(a[i]*x) for x in b]
print(" ".join(res))
```
| 51,674 | [
0.4482421875,
0.04034423828125,
-0.035400390625,
0.5,
-0.309814453125,
-0.442138671875,
-0.31201171875,
0.11810302734375,
0.22119140625,
0.5693359375,
0.6806640625,
0.0213623046875,
-0.12384033203125,
-0.34619140625,
-0.349853515625,
0.163330078125,
-0.9423828125,
-0.67724609375,
... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
While resting on the ship after the "Russian Code Cup" a boy named Misha invented an interesting game. He promised to give his quadrocopter to whoever will be the first one to make a rectangular table of size n × m, consisting of positive integers such that the sum of the squares of numbers for each row and each column was also a square.
Since checking the correctness of the table manually is difficult, Misha asks you to make each number in the table to not exceed 108.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 100) — the size of the table.
Output
Print the table that meets the condition: n lines containing m integers, separated by spaces. If there are multiple possible answers, you are allowed to print anyone. It is guaranteed that there exists at least one correct answer.
Examples
Input
1 1
Output
1
Input
1 2
Output
3 4
Submitted Solution:
```
def ff(x):
if x==1: return [1]
elif x==2: return [3,4]
elif x%2==1: return [x/2+1,2]+[1]*(x-2)
else: return [x/2-1]+[1]*(x-1)
n,m=map(int,input().split())
for a in ff(n):
for b in ff(m):
print (a*b,)
print()
```
No
| 51,675 | [
0.57080078125,
0.02752685546875,
0.0478515625,
0.460693359375,
-0.544921875,
-0.239501953125,
-0.28271484375,
0.299560546875,
0.09454345703125,
0.54443359375,
0.712890625,
0.30078125,
-0.119384765625,
-0.334228515625,
-0.279541015625,
0.0943603515625,
-0.822265625,
-0.7919921875,
... | 11 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Department of economic development of IT City created a model of city development till year 2100.
To prepare report about growth perspectives it is required to get growth estimates from the model.
To get the growth estimates it is required to solve a quadratic equation. Since the Department of economic development of IT City creates realistic models only, that quadratic equation has a solution, moreover there are exactly two different real roots.
The greater of these roots corresponds to the optimistic scenario, the smaller one corresponds to the pessimistic one. Help to get these estimates, first the optimistic, then the pessimistic one.
Input
The only line of the input contains three integers a, b, c ( - 1000 ≤ a, b, c ≤ 1000) — the coefficients of ax2 + bx + c = 0 equation.
Output
In the first line output the greater of the equation roots, in the second line output the smaller one. Absolute or relative error should not be greater than 10 - 6.
Examples
Input
1 30 200
Output
-10.000000000000000
-20.000000000000000
Tags: math
Correct Solution:
```
import math
a, b, c = list(map(int, input().split()))
delta = b*b-4*a*c
x1 = (-b-math.sqrt(delta))/(2*a)
x2 = (-b+math.sqrt(delta))/(2*a)
if(x1>=x2):
print(x1, end = ' ')
print(x2)
else:
print(x2, end = ' ')
print(x1)
```
| 51,740 | [
0.326171875,
0.1552734375,
0.18798828125,
0.1541748046875,
-0.480712890625,
-0.406005859375,
-0.07373046875,
0.11163330078125,
0.53076171875,
0.91748046875,
0.7919921875,
-0.51708984375,
0.160888671875,
-0.466552734375,
-0.1402587890625,
0.33154296875,
-0.495849609375,
-0.607910156... | 11 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Department of economic development of IT City created a model of city development till year 2100.
To prepare report about growth perspectives it is required to get growth estimates from the model.
To get the growth estimates it is required to solve a quadratic equation. Since the Department of economic development of IT City creates realistic models only, that quadratic equation has a solution, moreover there are exactly two different real roots.
The greater of these roots corresponds to the optimistic scenario, the smaller one corresponds to the pessimistic one. Help to get these estimates, first the optimistic, then the pessimistic one.
Input
The only line of the input contains three integers a, b, c ( - 1000 ≤ a, b, c ≤ 1000) — the coefficients of ax2 + bx + c = 0 equation.
Output
In the first line output the greater of the equation roots, in the second line output the smaller one. Absolute or relative error should not be greater than 10 - 6.
Examples
Input
1 30 200
Output
-10.000000000000000
-20.000000000000000
Tags: math
Correct Solution:
```
a,b,c=input().split(' ')
a=int(a)
b=int(b)
c=int(c)
d=(b*b-4*a*c)**0.5
print("{:.15f}".format(max((-b+d)/(2*a),(-b-d)/(2*a))))
print("{:.15f}".format(min((-b+d)/(2*a),(-b-d)/(2*a))))
```
| 51,742 | [
0.33642578125,
0.08868408203125,
0.166259765625,
0.172607421875,
-0.50927734375,
-0.44921875,
-0.0099334716796875,
0.1348876953125,
0.55078125,
0.84619140625,
0.7314453125,
-0.4580078125,
0.12841796875,
-0.42578125,
-0.1343994140625,
0.23388671875,
-0.4423828125,
-0.6591796875,
0... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Department of economic development of IT City created a model of city development till year 2100.
To prepare report about growth perspectives it is required to get growth estimates from the model.
To get the growth estimates it is required to solve a quadratic equation. Since the Department of economic development of IT City creates realistic models only, that quadratic equation has a solution, moreover there are exactly two different real roots.
The greater of these roots corresponds to the optimistic scenario, the smaller one corresponds to the pessimistic one. Help to get these estimates, first the optimistic, then the pessimistic one.
Input
The only line of the input contains three integers a, b, c ( - 1000 ≤ a, b, c ≤ 1000) — the coefficients of ax2 + bx + c = 0 equation.
Output
In the first line output the greater of the equation roots, in the second line output the smaller one. Absolute or relative error should not be greater than 10 - 6.
Examples
Input
1 30 200
Output
-10.000000000000000
-20.000000000000000
Submitted Solution:
```
from math import sqrt
a,b,c = map(int,input().split())
r = ((-b + sqrt(b*b-4*a*c))/(2*a))
r1 = ((-b - sqrt(b*b-4*a*c))/(2*a))
a = max(r,r1)
b = min(r,r1)
print(a)
print(b)
```
Yes
| 51,746 | [
0.36865234375,
0.12310791015625,
0.034912109375,
0.03668212890625,
-0.58642578125,
-0.327880859375,
-0.1229248046875,
0.272705078125,
0.421630859375,
0.86328125,
0.6357421875,
-0.47802734375,
0.08514404296875,
-0.55615234375,
-0.1859130859375,
0.1690673828125,
-0.494384765625,
-0.6... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Department of economic development of IT City created a model of city development till year 2100.
To prepare report about growth perspectives it is required to get growth estimates from the model.
To get the growth estimates it is required to solve a quadratic equation. Since the Department of economic development of IT City creates realistic models only, that quadratic equation has a solution, moreover there are exactly two different real roots.
The greater of these roots corresponds to the optimistic scenario, the smaller one corresponds to the pessimistic one. Help to get these estimates, first the optimistic, then the pessimistic one.
Input
The only line of the input contains three integers a, b, c ( - 1000 ≤ a, b, c ≤ 1000) — the coefficients of ax2 + bx + c = 0 equation.
Output
In the first line output the greater of the equation roots, in the second line output the smaller one. Absolute or relative error should not be greater than 10 - 6.
Examples
Input
1 30 200
Output
-10.000000000000000
-20.000000000000000
Submitted Solution:
```
a,b,c=map(float,input().split())
q=((b*b-4*a*c)**0.5)
x=((-b+q)/(2*a))
y=((-b-q)/(2*a))
print(max(x,y))
print(min(x,y))
```
Yes
| 51,747 | [
0.363037109375,
0.1419677734375,
0.018096923828125,
0.043487548828125,
-0.60107421875,
-0.33349609375,
-0.1092529296875,
0.279541015625,
0.4501953125,
0.88232421875,
0.62109375,
-0.438232421875,
0.11175537109375,
-0.599609375,
-0.177978515625,
0.15283203125,
-0.480712890625,
-0.679... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Department of economic development of IT City created a model of city development till year 2100.
To prepare report about growth perspectives it is required to get growth estimates from the model.
To get the growth estimates it is required to solve a quadratic equation. Since the Department of economic development of IT City creates realistic models only, that quadratic equation has a solution, moreover there are exactly two different real roots.
The greater of these roots corresponds to the optimistic scenario, the smaller one corresponds to the pessimistic one. Help to get these estimates, first the optimistic, then the pessimistic one.
Input
The only line of the input contains three integers a, b, c ( - 1000 ≤ a, b, c ≤ 1000) — the coefficients of ax2 + bx + c = 0 equation.
Output
In the first line output the greater of the equation roots, in the second line output the smaller one. Absolute or relative error should not be greater than 10 - 6.
Examples
Input
1 30 200
Output
-10.000000000000000
-20.000000000000000
Submitted Solution:
```
from math import *
a,b,c=map(int,input().split())
Delta=b**2-4*a*c
x1=(-b-sqrt(Delta))/(2*a)
x2=(-b+sqrt(Delta))/(2*a)
if x1>x2:
x2,x1=x1,x2
x2="%.7f" % x2
x1="%.7f" % x1
print(x2[:-1])
print(x1[:-1])
```
Yes
| 51,748 | [
0.33447265625,
0.183349609375,
0.046051025390625,
0.09039306640625,
-0.5546875,
-0.312744140625,
-0.1343994140625,
0.272216796875,
0.419189453125,
0.90234375,
0.6298828125,
-0.480224609375,
0.135986328125,
-0.6259765625,
-0.1859130859375,
0.235595703125,
-0.5361328125,
-0.704589843... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Department of economic development of IT City created a model of city development till year 2100.
To prepare report about growth perspectives it is required to get growth estimates from the model.
To get the growth estimates it is required to solve a quadratic equation. Since the Department of economic development of IT City creates realistic models only, that quadratic equation has a solution, moreover there are exactly two different real roots.
The greater of these roots corresponds to the optimistic scenario, the smaller one corresponds to the pessimistic one. Help to get these estimates, first the optimistic, then the pessimistic one.
Input
The only line of the input contains three integers a, b, c ( - 1000 ≤ a, b, c ≤ 1000) — the coefficients of ax2 + bx + c = 0 equation.
Output
In the first line output the greater of the equation roots, in the second line output the smaller one. Absolute or relative error should not be greater than 10 - 6.
Examples
Input
1 30 200
Output
-10.000000000000000
-20.000000000000000
Submitted Solution:
```
X = list (map (int, input ().split (' ')))
D = X [1] ** 2 - 4 * X [0] * X [2]
print (max ((- X [1] + D ** (1 / 2)) / (2 * X [0]), (- X [1] - D ** (1 / 2)) / (2 * X [0])))
print (min ((- X [1] + D ** (1 / 2)) / (2 * X [0]), (- X [1] - D ** (1 / 2)) / (2 * X [0])))
```
Yes
| 51,749 | [
0.304931640625,
0.14306640625,
0.03466796875,
0.07293701171875,
-0.58544921875,
-0.355712890625,
-0.12548828125,
0.275146484375,
0.425537109375,
0.86181640625,
0.61328125,
-0.370849609375,
0.16845703125,
-0.60888671875,
-0.1903076171875,
0.1861572265625,
-0.48193359375,
-0.70263671... | 11 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.