message stringlengths 2 20.1k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 1.95k 109k | cluster float64 17 17 | __index_level_0__ int64 3.91k 217k |
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
Professor GukiZ likes programming contests. He especially likes to rate his students on the contests he prepares. Now, he has decided to prepare a new contest.
In total, n students will attend, and before the start, every one of them has some positive integer rating. Students are indexed from 1 to n. Let's denote the rating of i-th student as ai. After the contest ends, every student will end up with some positive integer position. GukiZ expects that his students will take places according to their ratings.
He thinks that each student will take place equal to <image>. In particular, if student A has rating strictly lower then student B, A will get the strictly better position than B, and if two students have equal ratings, they will share the same position.
GukiZ would like you to reconstruct the results by following his expectations. Help him and determine the position after the end of the contest for each of his students if everything goes as expected.
Input
The first line contains integer n (1 β€ n β€ 2000), number of GukiZ's students.
The second line contains n numbers a1, a2, ... an (1 β€ ai β€ 2000) where ai is the rating of i-th student (1 β€ i β€ n).
Output
In a single line, print the position after the end of the contest for each of n students in the same order as they appear in the input.
Examples
Input
3
1 3 3
Output
3 1 1
Input
1
1
Output
1
Input
5
3 5 3 4 5
Output
4 1 4 3 1
Note
In the first sample, students 2 and 3 are positioned first (there is no other student with higher rating), and student 1 is positioned third since there are two students with higher rating.
In the second sample, first student is the only one on the contest.
In the third sample, students 2 and 5 share the first position with highest rating, student 4 is next with third position, and students 1 and 3 are the last sharing fourth position. | instruction | 0 | 26,926 | 17 | 53,852 |
Tags: brute force, implementation, sortings
Correct Solution:
```
n=int(input());
num=input()
lst=list(map(int,num.split()))
for i in range (0,n,1):
k=1
for j in range (0,n,1):
if(lst[i]<lst[j]):
k+=1
print(k,end=" ")
``` | output | 1 | 26,926 | 17 | 53,853 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Professor GukiZ likes programming contests. He especially likes to rate his students on the contests he prepares. Now, he has decided to prepare a new contest.
In total, n students will attend, and before the start, every one of them has some positive integer rating. Students are indexed from 1 to n. Let's denote the rating of i-th student as ai. After the contest ends, every student will end up with some positive integer position. GukiZ expects that his students will take places according to their ratings.
He thinks that each student will take place equal to <image>. In particular, if student A has rating strictly lower then student B, A will get the strictly better position than B, and if two students have equal ratings, they will share the same position.
GukiZ would like you to reconstruct the results by following his expectations. Help him and determine the position after the end of the contest for each of his students if everything goes as expected.
Input
The first line contains integer n (1 β€ n β€ 2000), number of GukiZ's students.
The second line contains n numbers a1, a2, ... an (1 β€ ai β€ 2000) where ai is the rating of i-th student (1 β€ i β€ n).
Output
In a single line, print the position after the end of the contest for each of n students in the same order as they appear in the input.
Examples
Input
3
1 3 3
Output
3 1 1
Input
1
1
Output
1
Input
5
3 5 3 4 5
Output
4 1 4 3 1
Note
In the first sample, students 2 and 3 are positioned first (there is no other student with higher rating), and student 1 is positioned third since there are two students with higher rating.
In the second sample, first student is the only one on the contest.
In the third sample, students 2 and 5 share the first position with highest rating, student 4 is next with third position, and students 1 and 3 are the last sharing fourth position. | instruction | 0 | 26,927 | 17 | 53,854 |
Tags: brute force, implementation, sortings
Correct Solution:
```
n=int(input())
l2=list(map(int,input().split()))
l=sorted(l2,reverse=True)
s=sorted(list(set(l)),reverse=True)
c=1
l1=[]
for i in s:
for j in range(l.count(i)):
l1.append(c)
c+=l.count(i)
d={}
for k in range(len(l)):
d[l[k]]=l1[k]
for m in l2:
print(d[m],end=' ')
``` | output | 1 | 26,927 | 17 | 53,855 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Professor GukiZ likes programming contests. He especially likes to rate his students on the contests he prepares. Now, he has decided to prepare a new contest.
In total, n students will attend, and before the start, every one of them has some positive integer rating. Students are indexed from 1 to n. Let's denote the rating of i-th student as ai. After the contest ends, every student will end up with some positive integer position. GukiZ expects that his students will take places according to their ratings.
He thinks that each student will take place equal to <image>. In particular, if student A has rating strictly lower then student B, A will get the strictly better position than B, and if two students have equal ratings, they will share the same position.
GukiZ would like you to reconstruct the results by following his expectations. Help him and determine the position after the end of the contest for each of his students if everything goes as expected.
Input
The first line contains integer n (1 β€ n β€ 2000), number of GukiZ's students.
The second line contains n numbers a1, a2, ... an (1 β€ ai β€ 2000) where ai is the rating of i-th student (1 β€ i β€ n).
Output
In a single line, print the position after the end of the contest for each of n students in the same order as they appear in the input.
Examples
Input
3
1 3 3
Output
3 1 1
Input
1
1
Output
1
Input
5
3 5 3 4 5
Output
4 1 4 3 1
Note
In the first sample, students 2 and 3 are positioned first (there is no other student with higher rating), and student 1 is positioned third since there are two students with higher rating.
In the second sample, first student is the only one on the contest.
In the third sample, students 2 and 5 share the first position with highest rating, student 4 is next with third position, and students 1 and 3 are the last sharing fourth position. | instruction | 0 | 26,928 | 17 | 53,856 |
Tags: brute force, implementation, sortings
Correct Solution:
```
n=int(input())
l = list(map(int,input().split()))
b =l.copy()
l.sort()
l.reverse()
for i in b:
print(l.index(i)+1,end = " ")
``` | output | 1 | 26,928 | 17 | 53,857 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Everybody knows that the m-coder Tournament will happen soon. m schools participate in the tournament, and only one student from each school participates.
There are a total of n students in those schools. Before the tournament, all students put their names and the names of their schools into the Technogoblet of Fire. After that, Technogoblet selects the strongest student from each school to participate.
Arkady is a hacker who wants to have k Chosen Ones selected by the Technogoblet. Unfortunately, not all of them are the strongest in their schools, but Arkady can make up some new school names and replace some names from Technogoblet with those. You can't use each made-up name more than once. In that case, Technogoblet would select the strongest student in those made-up schools too.
You know the power of each student and schools they study in. Calculate the minimal number of schools Arkady has to make up so that k Chosen Ones would be selected by the Technogoblet.
Input
The first line contains three integers n, m and k (1 β€ n β€ 100, 1 β€ m, k β€ n) β the total number of students, the number of schools and the number of the Chosen Ones.
The second line contains n different integers p_1, p_2, β¦, p_n (1 β€ p_i β€ n), where p_i denotes the power of i-th student. The bigger the power, the stronger the student.
The third line contains n integers s_1, s_2, β¦, s_n (1 β€ s_i β€ m), where s_i denotes the school the i-th student goes to. At least one student studies in each of the schools.
The fourth line contains k different integers c_1, c_2, β¦, c_k (1 β€ c_i β€ n) β the id's of the Chosen Ones.
Output
Output a single integer β the minimal number of schools to be made up by Arkady so that k Chosen Ones would be selected by the Technogoblet.
Examples
Input
7 3 1
1 5 3 4 6 7 2
1 3 1 2 1 2 3
3
Output
1
Input
8 4 4
1 2 3 4 5 6 7 8
4 3 2 1 4 3 2 1
3 4 5 6
Output
2
Note
In the first example there's just a single Chosen One with id 3. His power is equal to 3, but in the same school 1, there's a student with id 5 and power 6, and that means inaction would not lead to the latter being chosen. If we, however, make up a new school (let its id be 4) for the Chosen One, Technogoblet would select students with ids 2 (strongest in 3), 5 (strongest in 1), 6 (strongest in 2) and 3 (strongest in 4).
In the second example, you can change the school of student 3 to the made-up 5 and the school of student 4 to the made-up 6. It will cause the Technogoblet to choose students 8, 7, 6, 5, 3 and 4. | instruction | 0 | 27,461 | 17 | 54,922 |
Tags: implementation, sortings
Correct Solution:
```
from collections import defaultdict
n, m, k = map(int, input().split())
p = list(map(int, input().split()))
s = list(map(int, input().split()))
c = list(map(int, input().split()))
schools = defaultdict(lambda : [])
for i in range(0, n):
schools[s[i]].append((p[i], i + 1))
winners = set()
for i in range(1, m + 1):
schools[i].sort()
winners.add(schools[i][-1][1])
total = 0
for winner in c:
if winner not in winners:
total += 1
print(total)
``` | output | 1 | 27,461 | 17 | 54,923 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Everybody knows that the m-coder Tournament will happen soon. m schools participate in the tournament, and only one student from each school participates.
There are a total of n students in those schools. Before the tournament, all students put their names and the names of their schools into the Technogoblet of Fire. After that, Technogoblet selects the strongest student from each school to participate.
Arkady is a hacker who wants to have k Chosen Ones selected by the Technogoblet. Unfortunately, not all of them are the strongest in their schools, but Arkady can make up some new school names and replace some names from Technogoblet with those. You can't use each made-up name more than once. In that case, Technogoblet would select the strongest student in those made-up schools too.
You know the power of each student and schools they study in. Calculate the minimal number of schools Arkady has to make up so that k Chosen Ones would be selected by the Technogoblet.
Input
The first line contains three integers n, m and k (1 β€ n β€ 100, 1 β€ m, k β€ n) β the total number of students, the number of schools and the number of the Chosen Ones.
The second line contains n different integers p_1, p_2, β¦, p_n (1 β€ p_i β€ n), where p_i denotes the power of i-th student. The bigger the power, the stronger the student.
The third line contains n integers s_1, s_2, β¦, s_n (1 β€ s_i β€ m), where s_i denotes the school the i-th student goes to. At least one student studies in each of the schools.
The fourth line contains k different integers c_1, c_2, β¦, c_k (1 β€ c_i β€ n) β the id's of the Chosen Ones.
Output
Output a single integer β the minimal number of schools to be made up by Arkady so that k Chosen Ones would be selected by the Technogoblet.
Examples
Input
7 3 1
1 5 3 4 6 7 2
1 3 1 2 1 2 3
3
Output
1
Input
8 4 4
1 2 3 4 5 6 7 8
4 3 2 1 4 3 2 1
3 4 5 6
Output
2
Note
In the first example there's just a single Chosen One with id 3. His power is equal to 3, but in the same school 1, there's a student with id 5 and power 6, and that means inaction would not lead to the latter being chosen. If we, however, make up a new school (let its id be 4) for the Chosen One, Technogoblet would select students with ids 2 (strongest in 3), 5 (strongest in 1), 6 (strongest in 2) and 3 (strongest in 4).
In the second example, you can change the school of student 3 to the made-up 5 and the school of student 4 to the made-up 6. It will cause the Technogoblet to choose students 8, 7, 6, 5, 3 and 4. | instruction | 0 | 27,462 | 17 | 54,924 |
Tags: implementation, sortings
Correct Solution:
```
import sys
input = sys.stdin.readline
n, m, k = map(int, input().split())
p = list(map(int, input().split()))
schools = {}
for i in range(1, m+1):
schools[i] = []
s = list(map(int, input().split()))
for i in range(len(s)):
schools[s[i]].append((p[i], i+1))
chosen = set()
for i in range(1, m+1):
schools[i].sort(reverse = True)
chosen.add(schools[i][0][1])
specials = list(map(int, input().split()))
for i in specials:
if i in chosen:
k -= 1
print(k)
``` | output | 1 | 27,462 | 17 | 54,925 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Everybody knows that the m-coder Tournament will happen soon. m schools participate in the tournament, and only one student from each school participates.
There are a total of n students in those schools. Before the tournament, all students put their names and the names of their schools into the Technogoblet of Fire. After that, Technogoblet selects the strongest student from each school to participate.
Arkady is a hacker who wants to have k Chosen Ones selected by the Technogoblet. Unfortunately, not all of them are the strongest in their schools, but Arkady can make up some new school names and replace some names from Technogoblet with those. You can't use each made-up name more than once. In that case, Technogoblet would select the strongest student in those made-up schools too.
You know the power of each student and schools they study in. Calculate the minimal number of schools Arkady has to make up so that k Chosen Ones would be selected by the Technogoblet.
Input
The first line contains three integers n, m and k (1 β€ n β€ 100, 1 β€ m, k β€ n) β the total number of students, the number of schools and the number of the Chosen Ones.
The second line contains n different integers p_1, p_2, β¦, p_n (1 β€ p_i β€ n), where p_i denotes the power of i-th student. The bigger the power, the stronger the student.
The third line contains n integers s_1, s_2, β¦, s_n (1 β€ s_i β€ m), where s_i denotes the school the i-th student goes to. At least one student studies in each of the schools.
The fourth line contains k different integers c_1, c_2, β¦, c_k (1 β€ c_i β€ n) β the id's of the Chosen Ones.
Output
Output a single integer β the minimal number of schools to be made up by Arkady so that k Chosen Ones would be selected by the Technogoblet.
Examples
Input
7 3 1
1 5 3 4 6 7 2
1 3 1 2 1 2 3
3
Output
1
Input
8 4 4
1 2 3 4 5 6 7 8
4 3 2 1 4 3 2 1
3 4 5 6
Output
2
Note
In the first example there's just a single Chosen One with id 3. His power is equal to 3, but in the same school 1, there's a student with id 5 and power 6, and that means inaction would not lead to the latter being chosen. If we, however, make up a new school (let its id be 4) for the Chosen One, Technogoblet would select students with ids 2 (strongest in 3), 5 (strongest in 1), 6 (strongest in 2) and 3 (strongest in 4).
In the second example, you can change the school of student 3 to the made-up 5 and the school of student 4 to the made-up 6. It will cause the Technogoblet to choose students 8, 7, 6, 5, 3 and 4. | instruction | 0 | 27,463 | 17 | 54,926 |
Tags: implementation, sortings
Correct Solution:
```
from sys import stdin,stdout
import math
# stdin = open("input.txt", "r");
# stdout = open("output.txt", "w");
n,m,k=stdin.readline().strip().split(' ')
n,m,k=int(n),int(m),int(k)
power =list(map(int,stdin.readline().strip().split(' ')))
school =list(map(int,stdin.readline().strip().split(' ')))
selected=list(map(int,stdin.readline().strip().split(' ')))
max_power={}
taken={}
for i in range(len(power)):
if school[i] in max_power:
max_power[school[i]]=max(power[i],max_power[school[i]])
else:
max_power[school[i]]=power[i]
taken[school[i]]=0
ans=0;
for i in selected:
if power[i-1]==max_power[school[i-1]]:
if taken[school[i-1]]==0:
taken[school[i-1]]=1
else:
ans+=1
else:
ans+=1
stdout.write(str(ans)+"\n");
``` | output | 1 | 27,463 | 17 | 54,927 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Everybody knows that the m-coder Tournament will happen soon. m schools participate in the tournament, and only one student from each school participates.
There are a total of n students in those schools. Before the tournament, all students put their names and the names of their schools into the Technogoblet of Fire. After that, Technogoblet selects the strongest student from each school to participate.
Arkady is a hacker who wants to have k Chosen Ones selected by the Technogoblet. Unfortunately, not all of them are the strongest in their schools, but Arkady can make up some new school names and replace some names from Technogoblet with those. You can't use each made-up name more than once. In that case, Technogoblet would select the strongest student in those made-up schools too.
You know the power of each student and schools they study in. Calculate the minimal number of schools Arkady has to make up so that k Chosen Ones would be selected by the Technogoblet.
Input
The first line contains three integers n, m and k (1 β€ n β€ 100, 1 β€ m, k β€ n) β the total number of students, the number of schools and the number of the Chosen Ones.
The second line contains n different integers p_1, p_2, β¦, p_n (1 β€ p_i β€ n), where p_i denotes the power of i-th student. The bigger the power, the stronger the student.
The third line contains n integers s_1, s_2, β¦, s_n (1 β€ s_i β€ m), where s_i denotes the school the i-th student goes to. At least one student studies in each of the schools.
The fourth line contains k different integers c_1, c_2, β¦, c_k (1 β€ c_i β€ n) β the id's of the Chosen Ones.
Output
Output a single integer β the minimal number of schools to be made up by Arkady so that k Chosen Ones would be selected by the Technogoblet.
Examples
Input
7 3 1
1 5 3 4 6 7 2
1 3 1 2 1 2 3
3
Output
1
Input
8 4 4
1 2 3 4 5 6 7 8
4 3 2 1 4 3 2 1
3 4 5 6
Output
2
Note
In the first example there's just a single Chosen One with id 3. His power is equal to 3, but in the same school 1, there's a student with id 5 and power 6, and that means inaction would not lead to the latter being chosen. If we, however, make up a new school (let its id be 4) for the Chosen One, Technogoblet would select students with ids 2 (strongest in 3), 5 (strongest in 1), 6 (strongest in 2) and 3 (strongest in 4).
In the second example, you can change the school of student 3 to the made-up 5 and the school of student 4 to the made-up 6. It will cause the Technogoblet to choose students 8, 7, 6, 5, 3 and 4. | instruction | 0 | 27,464 | 17 | 54,928 |
Tags: implementation, sortings
Correct Solution:
```
n, m, k = list(map(int, input().split()))
arr = list(map(int, input().split()))
arr2 = list(map(int, input().split()))
arr3 = list(map(int, input().split()))
ans = {}
count = 0
for z in range(n):
if arr2[z] in ans:
ans[arr2[z]].append([arr[z], z+1])
else:
ans[arr2[z]] = [[arr[z], z+1]]
#print(ans)
for zz in arr3:
key = arr2[zz-1]
power = arr[zz-1]
ans[key].sort(reverse=True)
res = ans[key]
if res[0] != [power, zz]:
count += 1
ans[key].remove([power, zz])
print(count)
``` | output | 1 | 27,464 | 17 | 54,929 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Everybody knows that the m-coder Tournament will happen soon. m schools participate in the tournament, and only one student from each school participates.
There are a total of n students in those schools. Before the tournament, all students put their names and the names of their schools into the Technogoblet of Fire. After that, Technogoblet selects the strongest student from each school to participate.
Arkady is a hacker who wants to have k Chosen Ones selected by the Technogoblet. Unfortunately, not all of them are the strongest in their schools, but Arkady can make up some new school names and replace some names from Technogoblet with those. You can't use each made-up name more than once. In that case, Technogoblet would select the strongest student in those made-up schools too.
You know the power of each student and schools they study in. Calculate the minimal number of schools Arkady has to make up so that k Chosen Ones would be selected by the Technogoblet.
Input
The first line contains three integers n, m and k (1 β€ n β€ 100, 1 β€ m, k β€ n) β the total number of students, the number of schools and the number of the Chosen Ones.
The second line contains n different integers p_1, p_2, β¦, p_n (1 β€ p_i β€ n), where p_i denotes the power of i-th student. The bigger the power, the stronger the student.
The third line contains n integers s_1, s_2, β¦, s_n (1 β€ s_i β€ m), where s_i denotes the school the i-th student goes to. At least one student studies in each of the schools.
The fourth line contains k different integers c_1, c_2, β¦, c_k (1 β€ c_i β€ n) β the id's of the Chosen Ones.
Output
Output a single integer β the minimal number of schools to be made up by Arkady so that k Chosen Ones would be selected by the Technogoblet.
Examples
Input
7 3 1
1 5 3 4 6 7 2
1 3 1 2 1 2 3
3
Output
1
Input
8 4 4
1 2 3 4 5 6 7 8
4 3 2 1 4 3 2 1
3 4 5 6
Output
2
Note
In the first example there's just a single Chosen One with id 3. His power is equal to 3, but in the same school 1, there's a student with id 5 and power 6, and that means inaction would not lead to the latter being chosen. If we, however, make up a new school (let its id be 4) for the Chosen One, Technogoblet would select students with ids 2 (strongest in 3), 5 (strongest in 1), 6 (strongest in 2) and 3 (strongest in 4).
In the second example, you can change the school of student 3 to the made-up 5 and the school of student 4 to the made-up 6. It will cause the Technogoblet to choose students 8, 7, 6, 5, 3 and 4. | instruction | 0 | 27,465 | 17 | 54,930 |
Tags: implementation, sortings
Correct Solution:
```
n, m, k = map(int, input().split())
powers = list(map(int, input().split()))
schools = list(map(int, input().split()))
choosenones = list(map(int, input().split()))
most_power = [0] * (m+1)
students = zip(powers, schools)
for power, school in students:
most_power[school] = max(most_power[school], power)
counter = 0
for choosen in choosenones:
if most_power[schools[choosen-1]] != powers[choosen-1]:
counter += 1
print(counter)
``` | output | 1 | 27,465 | 17 | 54,931 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Everybody knows that the m-coder Tournament will happen soon. m schools participate in the tournament, and only one student from each school participates.
There are a total of n students in those schools. Before the tournament, all students put their names and the names of their schools into the Technogoblet of Fire. After that, Technogoblet selects the strongest student from each school to participate.
Arkady is a hacker who wants to have k Chosen Ones selected by the Technogoblet. Unfortunately, not all of them are the strongest in their schools, but Arkady can make up some new school names and replace some names from Technogoblet with those. You can't use each made-up name more than once. In that case, Technogoblet would select the strongest student in those made-up schools too.
You know the power of each student and schools they study in. Calculate the minimal number of schools Arkady has to make up so that k Chosen Ones would be selected by the Technogoblet.
Input
The first line contains three integers n, m and k (1 β€ n β€ 100, 1 β€ m, k β€ n) β the total number of students, the number of schools and the number of the Chosen Ones.
The second line contains n different integers p_1, p_2, β¦, p_n (1 β€ p_i β€ n), where p_i denotes the power of i-th student. The bigger the power, the stronger the student.
The third line contains n integers s_1, s_2, β¦, s_n (1 β€ s_i β€ m), where s_i denotes the school the i-th student goes to. At least one student studies in each of the schools.
The fourth line contains k different integers c_1, c_2, β¦, c_k (1 β€ c_i β€ n) β the id's of the Chosen Ones.
Output
Output a single integer β the minimal number of schools to be made up by Arkady so that k Chosen Ones would be selected by the Technogoblet.
Examples
Input
7 3 1
1 5 3 4 6 7 2
1 3 1 2 1 2 3
3
Output
1
Input
8 4 4
1 2 3 4 5 6 7 8
4 3 2 1 4 3 2 1
3 4 5 6
Output
2
Note
In the first example there's just a single Chosen One with id 3. His power is equal to 3, but in the same school 1, there's a student with id 5 and power 6, and that means inaction would not lead to the latter being chosen. If we, however, make up a new school (let its id be 4) for the Chosen One, Technogoblet would select students with ids 2 (strongest in 3), 5 (strongest in 1), 6 (strongest in 2) and 3 (strongest in 4).
In the second example, you can change the school of student 3 to the made-up 5 and the school of student 4 to the made-up 6. It will cause the Technogoblet to choose students 8, 7, 6, 5, 3 and 4. | instruction | 0 | 27,466 | 17 | 54,932 |
Tags: implementation, sortings
Correct Solution:
```
def get_maxPower_fromSchool(school_num):
max_ = 0
max_index = 0
for j in range(n):
if (school_array[j] == school_num and power_array[j] > max_):
max_ = power_array[j]
max_index = j
return max_
n, m, k = input().split()
n = int(n)
m = int(m)
k = int(k)
power_array = input().split()
school_array = input().split()
k_array = input().split()
for i in range(n):
power_array[i] = int(power_array[i])
school_array[i] = int(school_array[i])
for i in range(k):
k_array[i] = int(k_array[i])
school_add_counter = 0
#print(get_maxPower_fromSchool(2))
for i in range(k):
"""
print("current chosen i -> " + str(k_array[i]))
print("his power is -> " + str(power_array[k_array[i]-1]))
print("his school is -> " + str(school_array[k_array[i]-1]))
print("max from his school is -> " + str(get_maxPower_fromSchool(school_array[k_array[i]-1])))
print()
"""
if (power_array[k_array[i]-1] != get_maxPower_fromSchool(school_array[k_array[i]-1])):
school_add_counter += 1
print(school_add_counter)
``` | output | 1 | 27,466 | 17 | 54,933 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Everybody knows that the m-coder Tournament will happen soon. m schools participate in the tournament, and only one student from each school participates.
There are a total of n students in those schools. Before the tournament, all students put their names and the names of their schools into the Technogoblet of Fire. After that, Technogoblet selects the strongest student from each school to participate.
Arkady is a hacker who wants to have k Chosen Ones selected by the Technogoblet. Unfortunately, not all of them are the strongest in their schools, but Arkady can make up some new school names and replace some names from Technogoblet with those. You can't use each made-up name more than once. In that case, Technogoblet would select the strongest student in those made-up schools too.
You know the power of each student and schools they study in. Calculate the minimal number of schools Arkady has to make up so that k Chosen Ones would be selected by the Technogoblet.
Input
The first line contains three integers n, m and k (1 β€ n β€ 100, 1 β€ m, k β€ n) β the total number of students, the number of schools and the number of the Chosen Ones.
The second line contains n different integers p_1, p_2, β¦, p_n (1 β€ p_i β€ n), where p_i denotes the power of i-th student. The bigger the power, the stronger the student.
The third line contains n integers s_1, s_2, β¦, s_n (1 β€ s_i β€ m), where s_i denotes the school the i-th student goes to. At least one student studies in each of the schools.
The fourth line contains k different integers c_1, c_2, β¦, c_k (1 β€ c_i β€ n) β the id's of the Chosen Ones.
Output
Output a single integer β the minimal number of schools to be made up by Arkady so that k Chosen Ones would be selected by the Technogoblet.
Examples
Input
7 3 1
1 5 3 4 6 7 2
1 3 1 2 1 2 3
3
Output
1
Input
8 4 4
1 2 3 4 5 6 7 8
4 3 2 1 4 3 2 1
3 4 5 6
Output
2
Note
In the first example there's just a single Chosen One with id 3. His power is equal to 3, but in the same school 1, there's a student with id 5 and power 6, and that means inaction would not lead to the latter being chosen. If we, however, make up a new school (let its id be 4) for the Chosen One, Technogoblet would select students with ids 2 (strongest in 3), 5 (strongest in 1), 6 (strongest in 2) and 3 (strongest in 4).
In the second example, you can change the school of student 3 to the made-up 5 and the school of student 4 to the made-up 6. It will cause the Technogoblet to choose students 8, 7, 6, 5, 3 and 4. | instruction | 0 | 27,467 | 17 | 54,934 |
Tags: implementation, sortings
Correct Solution:
```
def TechnogobletofFire(n,m,k,p,s,c):
maxId = [0] * (m+1)
maxPower = [0] * (m+1)
i=0
while i<n:
if(maxPower[s[i]]<p[i]):
maxPower[s[i]] = p[i]
maxId[s[i]] = i+1
i+=1
res = 0
for element in c:
if element in maxId:
continue
else:
res+=1
return res
n,m,k = [int(x) for x in input().split()]
p = [int(x) for x in input().split()]
s = [int(x) for x in input().split()]
c = [int(x) for x in input().split()]
print(TechnogobletofFire(n,m,k,p,s,c))
``` | output | 1 | 27,467 | 17 | 54,935 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Everybody knows that the m-coder Tournament will happen soon. m schools participate in the tournament, and only one student from each school participates.
There are a total of n students in those schools. Before the tournament, all students put their names and the names of their schools into the Technogoblet of Fire. After that, Technogoblet selects the strongest student from each school to participate.
Arkady is a hacker who wants to have k Chosen Ones selected by the Technogoblet. Unfortunately, not all of them are the strongest in their schools, but Arkady can make up some new school names and replace some names from Technogoblet with those. You can't use each made-up name more than once. In that case, Technogoblet would select the strongest student in those made-up schools too.
You know the power of each student and schools they study in. Calculate the minimal number of schools Arkady has to make up so that k Chosen Ones would be selected by the Technogoblet.
Input
The first line contains three integers n, m and k (1 β€ n β€ 100, 1 β€ m, k β€ n) β the total number of students, the number of schools and the number of the Chosen Ones.
The second line contains n different integers p_1, p_2, β¦, p_n (1 β€ p_i β€ n), where p_i denotes the power of i-th student. The bigger the power, the stronger the student.
The third line contains n integers s_1, s_2, β¦, s_n (1 β€ s_i β€ m), where s_i denotes the school the i-th student goes to. At least one student studies in each of the schools.
The fourth line contains k different integers c_1, c_2, β¦, c_k (1 β€ c_i β€ n) β the id's of the Chosen Ones.
Output
Output a single integer β the minimal number of schools to be made up by Arkady so that k Chosen Ones would be selected by the Technogoblet.
Examples
Input
7 3 1
1 5 3 4 6 7 2
1 3 1 2 1 2 3
3
Output
1
Input
8 4 4
1 2 3 4 5 6 7 8
4 3 2 1 4 3 2 1
3 4 5 6
Output
2
Note
In the first example there's just a single Chosen One with id 3. His power is equal to 3, but in the same school 1, there's a student with id 5 and power 6, and that means inaction would not lead to the latter being chosen. If we, however, make up a new school (let its id be 4) for the Chosen One, Technogoblet would select students with ids 2 (strongest in 3), 5 (strongest in 1), 6 (strongest in 2) and 3 (strongest in 4).
In the second example, you can change the school of student 3 to the made-up 5 and the school of student 4 to the made-up 6. It will cause the Technogoblet to choose students 8, 7, 6, 5, 3 and 4. | instruction | 0 | 27,468 | 17 | 54,936 |
Tags: implementation, sortings
Correct Solution:
```
import sys
import math
from collections import defaultdict
def solve(n, m, k, p, s, c):
best = [float('-inf')] * m
for i in range(n):
best[s[i] - 1] = max(best[s[i] - 1], p[i])
res = 0
for ci in c:
if best[s[ci - 1] - 1] != p[ci - 1]:
res += 1
return res
if __name__ == '__main__':
n, m, k = map(int, input().split())
p = list(map(int, input().split()))
s = list(map(int, input().split()))
c = list(map(int, input().split()))
print(solve(n, m, k, p, s, c))
``` | output | 1 | 27,468 | 17 | 54,937 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Everybody knows that the m-coder Tournament will happen soon. m schools participate in the tournament, and only one student from each school participates.
There are a total of n students in those schools. Before the tournament, all students put their names and the names of their schools into the Technogoblet of Fire. After that, Technogoblet selects the strongest student from each school to participate.
Arkady is a hacker who wants to have k Chosen Ones selected by the Technogoblet. Unfortunately, not all of them are the strongest in their schools, but Arkady can make up some new school names and replace some names from Technogoblet with those. You can't use each made-up name more than once. In that case, Technogoblet would select the strongest student in those made-up schools too.
You know the power of each student and schools they study in. Calculate the minimal number of schools Arkady has to make up so that k Chosen Ones would be selected by the Technogoblet.
Input
The first line contains three integers n, m and k (1 β€ n β€ 100, 1 β€ m, k β€ n) β the total number of students, the number of schools and the number of the Chosen Ones.
The second line contains n different integers p_1, p_2, β¦, p_n (1 β€ p_i β€ n), where p_i denotes the power of i-th student. The bigger the power, the stronger the student.
The third line contains n integers s_1, s_2, β¦, s_n (1 β€ s_i β€ m), where s_i denotes the school the i-th student goes to. At least one student studies in each of the schools.
The fourth line contains k different integers c_1, c_2, β¦, c_k (1 β€ c_i β€ n) β the id's of the Chosen Ones.
Output
Output a single integer β the minimal number of schools to be made up by Arkady so that k Chosen Ones would be selected by the Technogoblet.
Examples
Input
7 3 1
1 5 3 4 6 7 2
1 3 1 2 1 2 3
3
Output
1
Input
8 4 4
1 2 3 4 5 6 7 8
4 3 2 1 4 3 2 1
3 4 5 6
Output
2
Note
In the first example there's just a single Chosen One with id 3. His power is equal to 3, but in the same school 1, there's a student with id 5 and power 6, and that means inaction would not lead to the latter being chosen. If we, however, make up a new school (let its id be 4) for the Chosen One, Technogoblet would select students with ids 2 (strongest in 3), 5 (strongest in 1), 6 (strongest in 2) and 3 (strongest in 4).
In the second example, you can change the school of student 3 to the made-up 5 and the school of student 4 to the made-up 6. It will cause the Technogoblet to choose students 8, 7, 6, 5, 3 and 4.
Submitted Solution:
```
n, m, k = map(int, input().split())
forces = list(map(int, input().split()))
schools = list(map(int, input().split()))
choose = list(map(int, input().split()))
res = 0
best = dict()
for i in range(n):
school = schools[i]
force = forces[i]
if school not in best or forces[best[school]] < force:
best[school] = i
res = 0
for student in choose:
student -= 1
if best[schools[student]] != student:
res += 1
print(res)
``` | instruction | 0 | 27,469 | 17 | 54,938 |
Yes | output | 1 | 27,469 | 17 | 54,939 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Everybody knows that the m-coder Tournament will happen soon. m schools participate in the tournament, and only one student from each school participates.
There are a total of n students in those schools. Before the tournament, all students put their names and the names of their schools into the Technogoblet of Fire. After that, Technogoblet selects the strongest student from each school to participate.
Arkady is a hacker who wants to have k Chosen Ones selected by the Technogoblet. Unfortunately, not all of them are the strongest in their schools, but Arkady can make up some new school names and replace some names from Technogoblet with those. You can't use each made-up name more than once. In that case, Technogoblet would select the strongest student in those made-up schools too.
You know the power of each student and schools they study in. Calculate the minimal number of schools Arkady has to make up so that k Chosen Ones would be selected by the Technogoblet.
Input
The first line contains three integers n, m and k (1 β€ n β€ 100, 1 β€ m, k β€ n) β the total number of students, the number of schools and the number of the Chosen Ones.
The second line contains n different integers p_1, p_2, β¦, p_n (1 β€ p_i β€ n), where p_i denotes the power of i-th student. The bigger the power, the stronger the student.
The third line contains n integers s_1, s_2, β¦, s_n (1 β€ s_i β€ m), where s_i denotes the school the i-th student goes to. At least one student studies in each of the schools.
The fourth line contains k different integers c_1, c_2, β¦, c_k (1 β€ c_i β€ n) β the id's of the Chosen Ones.
Output
Output a single integer β the minimal number of schools to be made up by Arkady so that k Chosen Ones would be selected by the Technogoblet.
Examples
Input
7 3 1
1 5 3 4 6 7 2
1 3 1 2 1 2 3
3
Output
1
Input
8 4 4
1 2 3 4 5 6 7 8
4 3 2 1 4 3 2 1
3 4 5 6
Output
2
Note
In the first example there's just a single Chosen One with id 3. His power is equal to 3, but in the same school 1, there's a student with id 5 and power 6, and that means inaction would not lead to the latter being chosen. If we, however, make up a new school (let its id be 4) for the Chosen One, Technogoblet would select students with ids 2 (strongest in 3), 5 (strongest in 1), 6 (strongest in 2) and 3 (strongest in 4).
In the second example, you can change the school of student 3 to the made-up 5 and the school of student 4 to the made-up 6. It will cause the Technogoblet to choose students 8, 7, 6, 5, 3 and 4.
Submitted Solution:
```
n, m, k = map(int, input().split())
p = list(map(int, input().split()))
s = list(map(int, input().split()))
c = list(map(lambda x: int(x) - 1, input().split()))
school = dict()
for i, si in enumerate(s):
if si in school:
school[si] = max(school[si], p[i])
else:
school[si] = p[i]
ans = 0
for ci in c:
if school[s[ci]] != p[ci]:
ans += 1
print(ans)
``` | instruction | 0 | 27,470 | 17 | 54,940 |
Yes | output | 1 | 27,470 | 17 | 54,941 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Everybody knows that the m-coder Tournament will happen soon. m schools participate in the tournament, and only one student from each school participates.
There are a total of n students in those schools. Before the tournament, all students put their names and the names of their schools into the Technogoblet of Fire. After that, Technogoblet selects the strongest student from each school to participate.
Arkady is a hacker who wants to have k Chosen Ones selected by the Technogoblet. Unfortunately, not all of them are the strongest in their schools, but Arkady can make up some new school names and replace some names from Technogoblet with those. You can't use each made-up name more than once. In that case, Technogoblet would select the strongest student in those made-up schools too.
You know the power of each student and schools they study in. Calculate the minimal number of schools Arkady has to make up so that k Chosen Ones would be selected by the Technogoblet.
Input
The first line contains three integers n, m and k (1 β€ n β€ 100, 1 β€ m, k β€ n) β the total number of students, the number of schools and the number of the Chosen Ones.
The second line contains n different integers p_1, p_2, β¦, p_n (1 β€ p_i β€ n), where p_i denotes the power of i-th student. The bigger the power, the stronger the student.
The third line contains n integers s_1, s_2, β¦, s_n (1 β€ s_i β€ m), where s_i denotes the school the i-th student goes to. At least one student studies in each of the schools.
The fourth line contains k different integers c_1, c_2, β¦, c_k (1 β€ c_i β€ n) β the id's of the Chosen Ones.
Output
Output a single integer β the minimal number of schools to be made up by Arkady so that k Chosen Ones would be selected by the Technogoblet.
Examples
Input
7 3 1
1 5 3 4 6 7 2
1 3 1 2 1 2 3
3
Output
1
Input
8 4 4
1 2 3 4 5 6 7 8
4 3 2 1 4 3 2 1
3 4 5 6
Output
2
Note
In the first example there's just a single Chosen One with id 3. His power is equal to 3, but in the same school 1, there's a student with id 5 and power 6, and that means inaction would not lead to the latter being chosen. If we, however, make up a new school (let its id be 4) for the Chosen One, Technogoblet would select students with ids 2 (strongest in 3), 5 (strongest in 1), 6 (strongest in 2) and 3 (strongest in 4).
In the second example, you can change the school of student 3 to the made-up 5 and the school of student 4 to the made-up 6. It will cause the Technogoblet to choose students 8, 7, 6, 5, 3 and 4.
Submitted Solution:
```
n,m,k=list(map(int,input().split()))
pl=list(map(int,input().split()))
s=list(map(int,input().split()))
c=list(map(int,input().split()))
ns=0
for i in range(k):
rs=s[c[i]-1]
for j in range(n):
if s[j]==rs:
if pl[j]>pl[c[i]-1]:
ns+=1
break
print(ns)
``` | instruction | 0 | 27,471 | 17 | 54,942 |
Yes | output | 1 | 27,471 | 17 | 54,943 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Everybody knows that the m-coder Tournament will happen soon. m schools participate in the tournament, and only one student from each school participates.
There are a total of n students in those schools. Before the tournament, all students put their names and the names of their schools into the Technogoblet of Fire. After that, Technogoblet selects the strongest student from each school to participate.
Arkady is a hacker who wants to have k Chosen Ones selected by the Technogoblet. Unfortunately, not all of them are the strongest in their schools, but Arkady can make up some new school names and replace some names from Technogoblet with those. You can't use each made-up name more than once. In that case, Technogoblet would select the strongest student in those made-up schools too.
You know the power of each student and schools they study in. Calculate the minimal number of schools Arkady has to make up so that k Chosen Ones would be selected by the Technogoblet.
Input
The first line contains three integers n, m and k (1 β€ n β€ 100, 1 β€ m, k β€ n) β the total number of students, the number of schools and the number of the Chosen Ones.
The second line contains n different integers p_1, p_2, β¦, p_n (1 β€ p_i β€ n), where p_i denotes the power of i-th student. The bigger the power, the stronger the student.
The third line contains n integers s_1, s_2, β¦, s_n (1 β€ s_i β€ m), where s_i denotes the school the i-th student goes to. At least one student studies in each of the schools.
The fourth line contains k different integers c_1, c_2, β¦, c_k (1 β€ c_i β€ n) β the id's of the Chosen Ones.
Output
Output a single integer β the minimal number of schools to be made up by Arkady so that k Chosen Ones would be selected by the Technogoblet.
Examples
Input
7 3 1
1 5 3 4 6 7 2
1 3 1 2 1 2 3
3
Output
1
Input
8 4 4
1 2 3 4 5 6 7 8
4 3 2 1 4 3 2 1
3 4 5 6
Output
2
Note
In the first example there's just a single Chosen One with id 3. His power is equal to 3, but in the same school 1, there's a student with id 5 and power 6, and that means inaction would not lead to the latter being chosen. If we, however, make up a new school (let its id be 4) for the Chosen One, Technogoblet would select students with ids 2 (strongest in 3), 5 (strongest in 1), 6 (strongest in 2) and 3 (strongest in 4).
In the second example, you can change the school of student 3 to the made-up 5 and the school of student 4 to the made-up 6. It will cause the Technogoblet to choose students 8, 7, 6, 5, 3 and 4.
Submitted Solution:
```
n, m, k = map(int,input().split())
l = [0] + list(map(int,input().split()))
k = [0] + list(map(int,input().split()))
d = list(map(int,input().split()))
s = 0
if len(l) == len(set(l)) and len(d) == len(set(d)):
for i in d:
c = l[i]
c = l.index(c)
c = k[c]
h = []
for x in range(len(k)):
if k[x] == c:
h.append(l[x])
if l[i] != max(h):
s += 1
print(s)
``` | instruction | 0 | 27,472 | 17 | 54,944 |
Yes | output | 1 | 27,472 | 17 | 54,945 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Everybody knows that the m-coder Tournament will happen soon. m schools participate in the tournament, and only one student from each school participates.
There are a total of n students in those schools. Before the tournament, all students put their names and the names of their schools into the Technogoblet of Fire. After that, Technogoblet selects the strongest student from each school to participate.
Arkady is a hacker who wants to have k Chosen Ones selected by the Technogoblet. Unfortunately, not all of them are the strongest in their schools, but Arkady can make up some new school names and replace some names from Technogoblet with those. You can't use each made-up name more than once. In that case, Technogoblet would select the strongest student in those made-up schools too.
You know the power of each student and schools they study in. Calculate the minimal number of schools Arkady has to make up so that k Chosen Ones would be selected by the Technogoblet.
Input
The first line contains three integers n, m and k (1 β€ n β€ 100, 1 β€ m, k β€ n) β the total number of students, the number of schools and the number of the Chosen Ones.
The second line contains n different integers p_1, p_2, β¦, p_n (1 β€ p_i β€ n), where p_i denotes the power of i-th student. The bigger the power, the stronger the student.
The third line contains n integers s_1, s_2, β¦, s_n (1 β€ s_i β€ m), where s_i denotes the school the i-th student goes to. At least one student studies in each of the schools.
The fourth line contains k different integers c_1, c_2, β¦, c_k (1 β€ c_i β€ n) β the id's of the Chosen Ones.
Output
Output a single integer β the minimal number of schools to be made up by Arkady so that k Chosen Ones would be selected by the Technogoblet.
Examples
Input
7 3 1
1 5 3 4 6 7 2
1 3 1 2 1 2 3
3
Output
1
Input
8 4 4
1 2 3 4 5 6 7 8
4 3 2 1 4 3 2 1
3 4 5 6
Output
2
Note
In the first example there's just a single Chosen One with id 3. His power is equal to 3, but in the same school 1, there's a student with id 5 and power 6, and that means inaction would not lead to the latter being chosen. If we, however, make up a new school (let its id be 4) for the Chosen One, Technogoblet would select students with ids 2 (strongest in 3), 5 (strongest in 1), 6 (strongest in 2) and 3 (strongest in 4).
In the second example, you can change the school of student 3 to the made-up 5 and the school of student 4 to the made-up 6. It will cause the Technogoblet to choose students 8, 7, 6, 5, 3 and 4.
Submitted Solution:
```
from sys import stdin
# the total number of students, the number of schools and the number of the Chosen Ones.
n, m, k = list(map(int, stdin.readline().split()))
student = list(map(int, stdin.readline().split()))
schools = list(map(int, stdin.readline().split()))
id = list(map(int, stdin.readline().split()))
high = max(schools)
dic = {i: [] for i in range(1, high+1)}
for i in range(len(schools)):
dic[schools[i]].append(student[i])
ans = 0
for stu in id:
school = schools[student.index(stu)]
if stu != max(dic[school]):
ans += 1
print(ans)
``` | instruction | 0 | 27,473 | 17 | 54,946 |
No | output | 1 | 27,473 | 17 | 54,947 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Everybody knows that the m-coder Tournament will happen soon. m schools participate in the tournament, and only one student from each school participates.
There are a total of n students in those schools. Before the tournament, all students put their names and the names of their schools into the Technogoblet of Fire. After that, Technogoblet selects the strongest student from each school to participate.
Arkady is a hacker who wants to have k Chosen Ones selected by the Technogoblet. Unfortunately, not all of them are the strongest in their schools, but Arkady can make up some new school names and replace some names from Technogoblet with those. You can't use each made-up name more than once. In that case, Technogoblet would select the strongest student in those made-up schools too.
You know the power of each student and schools they study in. Calculate the minimal number of schools Arkady has to make up so that k Chosen Ones would be selected by the Technogoblet.
Input
The first line contains three integers n, m and k (1 β€ n β€ 100, 1 β€ m, k β€ n) β the total number of students, the number of schools and the number of the Chosen Ones.
The second line contains n different integers p_1, p_2, β¦, p_n (1 β€ p_i β€ n), where p_i denotes the power of i-th student. The bigger the power, the stronger the student.
The third line contains n integers s_1, s_2, β¦, s_n (1 β€ s_i β€ m), where s_i denotes the school the i-th student goes to. At least one student studies in each of the schools.
The fourth line contains k different integers c_1, c_2, β¦, c_k (1 β€ c_i β€ n) β the id's of the Chosen Ones.
Output
Output a single integer β the minimal number of schools to be made up by Arkady so that k Chosen Ones would be selected by the Technogoblet.
Examples
Input
7 3 1
1 5 3 4 6 7 2
1 3 1 2 1 2 3
3
Output
1
Input
8 4 4
1 2 3 4 5 6 7 8
4 3 2 1 4 3 2 1
3 4 5 6
Output
2
Note
In the first example there's just a single Chosen One with id 3. His power is equal to 3, but in the same school 1, there's a student with id 5 and power 6, and that means inaction would not lead to the latter being chosen. If we, however, make up a new school (let its id be 4) for the Chosen One, Technogoblet would select students with ids 2 (strongest in 3), 5 (strongest in 1), 6 (strongest in 2) and 3 (strongest in 4).
In the second example, you can change the school of student 3 to the made-up 5 and the school of student 4 to the made-up 6. It will cause the Technogoblet to choose students 8, 7, 6, 5, 3 and 4.
Submitted Solution:
```
n, m, k = [int(x) for x in input().split()] # n - οΏ½οΏ½οΏ½-οΏ½οΏ½ οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½ , m - οΏ½οΏ½οΏ½οΏ½οΏ½ οΏ½οΏ½οΏ½οΏ½ , k - οΏ½οΏ½οΏ½οΏ½οΏ½ οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½ οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½
powers = [int(x) for x in input().split()] # οΏ½οΏ½οΏ½οΏ½ οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½
schools = [int(x) for x in input().split()]
needed = [int(x) for x in input().split()]
best = [-1] * int(m + 1)
count = 0
for i in range(1, n + 1):
school = schools[i - 1]
power = powers[i - 1]
if best[school] == -1:
best[school] = i
elif power > powers[best[school]]:
best[school] = i
for n in needed:
if n not in best:
count += 1
print(count)
``` | instruction | 0 | 27,474 | 17 | 54,948 |
No | output | 1 | 27,474 | 17 | 54,949 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Everybody knows that the m-coder Tournament will happen soon. m schools participate in the tournament, and only one student from each school participates.
There are a total of n students in those schools. Before the tournament, all students put their names and the names of their schools into the Technogoblet of Fire. After that, Technogoblet selects the strongest student from each school to participate.
Arkady is a hacker who wants to have k Chosen Ones selected by the Technogoblet. Unfortunately, not all of them are the strongest in their schools, but Arkady can make up some new school names and replace some names from Technogoblet with those. You can't use each made-up name more than once. In that case, Technogoblet would select the strongest student in those made-up schools too.
You know the power of each student and schools they study in. Calculate the minimal number of schools Arkady has to make up so that k Chosen Ones would be selected by the Technogoblet.
Input
The first line contains three integers n, m and k (1 β€ n β€ 100, 1 β€ m, k β€ n) β the total number of students, the number of schools and the number of the Chosen Ones.
The second line contains n different integers p_1, p_2, β¦, p_n (1 β€ p_i β€ n), where p_i denotes the power of i-th student. The bigger the power, the stronger the student.
The third line contains n integers s_1, s_2, β¦, s_n (1 β€ s_i β€ m), where s_i denotes the school the i-th student goes to. At least one student studies in each of the schools.
The fourth line contains k different integers c_1, c_2, β¦, c_k (1 β€ c_i β€ n) β the id's of the Chosen Ones.
Output
Output a single integer β the minimal number of schools to be made up by Arkady so that k Chosen Ones would be selected by the Technogoblet.
Examples
Input
7 3 1
1 5 3 4 6 7 2
1 3 1 2 1 2 3
3
Output
1
Input
8 4 4
1 2 3 4 5 6 7 8
4 3 2 1 4 3 2 1
3 4 5 6
Output
2
Note
In the first example there's just a single Chosen One with id 3. His power is equal to 3, but in the same school 1, there's a student with id 5 and power 6, and that means inaction would not lead to the latter being chosen. If we, however, make up a new school (let its id be 4) for the Chosen One, Technogoblet would select students with ids 2 (strongest in 3), 5 (strongest in 1), 6 (strongest in 2) and 3 (strongest in 4).
In the second example, you can change the school of student 3 to the made-up 5 and the school of student 4 to the made-up 6. It will cause the Technogoblet to choose students 8, 7, 6, 5, 3 and 4.
Submitted Solution:
```
n,m,k = map(int,input().split(" "))
power = list(map(int,input().split(" ")))
school= list(map(int,input().split(" ")))
choosen= list(map(int,input().split(" ")))
top_in_school = [0]*(m+1)
id_school = {}
for i in range(n):
id_school[power[i]] = school[i]
for i in range(n):
if top_in_school[school[i]] < power[i]:
top_in_school[school[i]] = power[i]
res = 0
for elem in choosen:
if top_in_school[id_school[elem]] > elem:
res+=1
print(res)
``` | instruction | 0 | 27,475 | 17 | 54,950 |
No | output | 1 | 27,475 | 17 | 54,951 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Everybody knows that the m-coder Tournament will happen soon. m schools participate in the tournament, and only one student from each school participates.
There are a total of n students in those schools. Before the tournament, all students put their names and the names of their schools into the Technogoblet of Fire. After that, Technogoblet selects the strongest student from each school to participate.
Arkady is a hacker who wants to have k Chosen Ones selected by the Technogoblet. Unfortunately, not all of them are the strongest in their schools, but Arkady can make up some new school names and replace some names from Technogoblet with those. You can't use each made-up name more than once. In that case, Technogoblet would select the strongest student in those made-up schools too.
You know the power of each student and schools they study in. Calculate the minimal number of schools Arkady has to make up so that k Chosen Ones would be selected by the Technogoblet.
Input
The first line contains three integers n, m and k (1 β€ n β€ 100, 1 β€ m, k β€ n) β the total number of students, the number of schools and the number of the Chosen Ones.
The second line contains n different integers p_1, p_2, β¦, p_n (1 β€ p_i β€ n), where p_i denotes the power of i-th student. The bigger the power, the stronger the student.
The third line contains n integers s_1, s_2, β¦, s_n (1 β€ s_i β€ m), where s_i denotes the school the i-th student goes to. At least one student studies in each of the schools.
The fourth line contains k different integers c_1, c_2, β¦, c_k (1 β€ c_i β€ n) β the id's of the Chosen Ones.
Output
Output a single integer β the minimal number of schools to be made up by Arkady so that k Chosen Ones would be selected by the Technogoblet.
Examples
Input
7 3 1
1 5 3 4 6 7 2
1 3 1 2 1 2 3
3
Output
1
Input
8 4 4
1 2 3 4 5 6 7 8
4 3 2 1 4 3 2 1
3 4 5 6
Output
2
Note
In the first example there's just a single Chosen One with id 3. His power is equal to 3, but in the same school 1, there's a student with id 5 and power 6, and that means inaction would not lead to the latter being chosen. If we, however, make up a new school (let its id be 4) for the Chosen One, Technogoblet would select students with ids 2 (strongest in 3), 5 (strongest in 1), 6 (strongest in 2) and 3 (strongest in 4).
In the second example, you can change the school of student 3 to the made-up 5 and the school of student 4 to the made-up 6. It will cause the Technogoblet to choose students 8, 7, 6, 5, 3 and 4.
Submitted Solution:
```
n,m,k = map(int,input().split())
p = list(map(int,input().split()))
s = list(map(int,input().split()))
c = list(map(int,input().split()))
f = 0
mps = [0 for i in range(max(s))]
for i in range(max(s)):
for j in range(n):
if (p[j]>p[mps[i]]) and (s[j]==(i+1)):
mps[i]=j
for i in range(k):
if ((c[i]-1) in mps)==False:
f+=1
print(f)
``` | instruction | 0 | 27,476 | 17 | 54,952 |
No | output | 1 | 27,476 | 17 | 54,953 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The biggest event of the year β Cota 2 world championship "The Innernational" is right around the corner. 2^n teams will compete in a double-elimination format (please, carefully read problem statement even if you know what is it) to identify the champion.
Teams are numbered from 1 to 2^n and will play games one-on-one. All teams start in the upper bracket.
All upper bracket matches will be held played between teams that haven't lost any games yet. Teams are split into games by team numbers. Game winner advances in the next round of upper bracket, losers drop into the lower bracket.
Lower bracket starts with 2^{n-1} teams that lost the first upper bracket game. Each lower bracket round consists of two games. In the first game of a round 2^k teams play a game with each other (teams are split into games by team numbers). 2^{k-1} loosing teams are eliminated from the championship, 2^{k-1} winning teams are playing 2^{k-1} teams that got eliminated in this round of upper bracket (again, teams are split into games by team numbers). As a result of each round both upper and lower bracket have 2^{k-1} teams remaining. See example notes for better understanding.
Single remaining team of upper bracket plays with single remaining team of lower bracket in grand-finals to identify championship winner.
You are a fan of teams with numbers a_1, a_2, ..., a_k. You want the championship to have as many games with your favourite teams as possible. Luckily, you can affect results of every championship game the way you want. What's maximal possible number of championship games that include teams you're fan of?
Input
First input line has two integers n, k β 2^n teams are competing in the championship. You are a fan of k teams (2 β€ n β€ 17; 0 β€ k β€ 2^n).
Second input line has k distinct integers a_1, β¦, a_k β numbers of teams you're a fan of (1 β€ a_i β€ 2^n).
Output
Output single integer β maximal possible number of championship games that include teams you're fan of.
Examples
Input
3 1
6
Output
6
Input
3 3
1 7 8
Output
11
Input
3 4
1 3 5 7
Output
14
Note
On the image, each game of the championship is denoted with an English letter (a to n). Winner of game i is denoted as Wi, loser is denoted as Li. Teams you're a fan of are highlighted with red background.
In the first example, team 6 will play in 6 games if it looses the first upper bracket game (game c) and wins all lower bracket games (games h, j, l, m).
<image>
In the second example, teams 7 and 8 have to play with each other in the first game of upper bracket (game d). Team 8 can win all remaining games in upper bracket, when teams 1 and 7 will compete in the lower bracket.
<image>
In the third example, your favourite teams can play in all games of the championship.
<image>
Submitted Solution:
```
from sys import stdin,stderr
def rl():
return [int(w) for w in stdin.readline().split()]
n,k = rl()
a = rl()
r = set()
def f(x, ld):
rr = []
for l in range(n):
p = (x-1) // 2**(l+1)
if l <= ld:
rr.append((l,1,p))
if l > ld:
rr.append((l,2,p))
if l >= ld and l > 0:
rr.append((l,3,p))
rr = [m for m in rr if m not in r]
return len(rr), rr
for x in a:
_, ms = max(f(x, ld) for ld in range(n+1))
for m in ms:
r.add(m)
print(len(r) + 1 if k else 0)
``` | instruction | 0 | 27,561 | 17 | 55,122 |
No | output | 1 | 27,561 | 17 | 55,123 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The biggest event of the year β Cota 2 world championship "The Innernational" is right around the corner. 2^n teams will compete in a double-elimination format (please, carefully read problem statement even if you know what is it) to identify the champion.
Teams are numbered from 1 to 2^n and will play games one-on-one. All teams start in the upper bracket.
All upper bracket matches will be held played between teams that haven't lost any games yet. Teams are split into games by team numbers. Game winner advances in the next round of upper bracket, losers drop into the lower bracket.
Lower bracket starts with 2^{n-1} teams that lost the first upper bracket game. Each lower bracket round consists of two games. In the first game of a round 2^k teams play a game with each other (teams are split into games by team numbers). 2^{k-1} loosing teams are eliminated from the championship, 2^{k-1} winning teams are playing 2^{k-1} teams that got eliminated in this round of upper bracket (again, teams are split into games by team numbers). As a result of each round both upper and lower bracket have 2^{k-1} teams remaining. See example notes for better understanding.
Single remaining team of upper bracket plays with single remaining team of lower bracket in grand-finals to identify championship winner.
You are a fan of teams with numbers a_1, a_2, ..., a_k. You want the championship to have as many games with your favourite teams as possible. Luckily, you can affect results of every championship game the way you want. What's maximal possible number of championship games that include teams you're fan of?
Input
First input line has two integers n, k β 2^n teams are competing in the championship. You are a fan of k teams (2 β€ n β€ 17; 0 β€ k β€ 2^n).
Second input line has k distinct integers a_1, β¦, a_k β numbers of teams you're a fan of (1 β€ a_i β€ 2^n).
Output
Output single integer β maximal possible number of championship games that include teams you're fan of.
Examples
Input
3 1
6
Output
6
Input
3 3
1 7 8
Output
11
Input
3 4
1 3 5 7
Output
14
Note
On the image, each game of the championship is denoted with an English letter (a to n). Winner of game i is denoted as Wi, loser is denoted as Li. Teams you're a fan of are highlighted with red background.
In the first example, team 6 will play in 6 games if it looses the first upper bracket game (game c) and wins all lower bracket games (games h, j, l, m).
<image>
In the second example, teams 7 and 8 have to play with each other in the first game of upper bracket (game d). Team 8 can win all remaining games in upper bracket, when teams 1 and 7 will compete in the lower bracket.
<image>
In the third example, your favourite teams can play in all games of the championship.
<image>
Submitted Solution:
```
from sys import stdin, gettrace
if not gettrace():
def input():
return next(stdin)[:-1]
def main():
n,k = map(int, input().split())
if k == 0:
print(0)
return
aa = [int(a) for a in input().split()]
aa.sort()
ub = [-1]*n
lb = [-1]*2*n
res = 1
last = -1
for a in aa:
# Win every match until meeting favorite
winc = -1 if (a+1)//2 == (last+1)//2 else 0
met = False
a1 = a
lp = n
for i in range(n):
a1 = (a1+1)//2
if met:
if a1 == lb[i*2]:
break
winc += 1
if a1 == lb[i*2+1]:
break
winc += 1
if a1 == ub[i]:
met = True
lp = i
if not met:
winc += 1
a2 = (a+1)//2
losec = 0 if (a+1)//2 == (last+1)//2 else 1
for i in range(1, n):
a2 = (a2+1) // 2
if a2 == lb[i * 2]:
break
losec += 1
if a2 == lb[i * 2 + 1]:
break
losec += 1
last = a
if winc > losec:
for i in range(n):
a = (a+1)//2
ub[i] = a
if i > lp:
lb[i*2] = a
lb[i*2+1] = a
res += winc
else:
a = (a+1)//2
for i in range(1,n):
a = (a+1)//2
lb[i*2] = a
lb[i*2+1] = a
res += losec
print(res)
if __name__ == "__main__":
main()
``` | instruction | 0 | 27,562 | 17 | 55,124 |
No | output | 1 | 27,562 | 17 | 55,125 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Another programming contest is over. You got hold of the contest's final results table. The table has the following data. For each team we are shown two numbers: the number of problems and the total penalty time. However, for no team we are shown its final place.
You know the rules of comparing the results of two given teams very well. Let's say that team a solved pa problems with total penalty time ta and team b solved pb problems with total penalty time tb. Team a gets a higher place than team b in the end, if it either solved more problems on the contest, or solved the same number of problems but in less total time. In other words, team a gets a higher place than team b in the final results' table if either pa > pb, or pa = pb and ta < tb.
It is considered that the teams that solve the same number of problems with the same penalty time share all corresponding places. More formally, let's say there is a group of x teams that solved the same number of problems with the same penalty time. Let's also say that y teams performed better than the teams from this group. In this case all teams from the group share places y + 1, y + 2, ..., y + x. The teams that performed worse than the teams from this group, get their places in the results table starting from the y + x + 1-th place.
Your task is to count what number of teams from the given list shared the k-th place.
Input
The first line contains two integers n and k (1 β€ k β€ n β€ 50). Then n lines contain the description of the teams: the i-th line contains two integers pi and ti (1 β€ pi, ti β€ 50) β the number of solved problems and the total penalty time of the i-th team, correspondingly. All numbers in the lines are separated by spaces.
Output
In the only line print the sought number of teams that got the k-th place in the final results' table.
Examples
Input
7 2
4 10
4 10
4 10
3 20
2 1
2 1
1 10
Output
3
Input
5 4
3 1
3 1
5 3
3 1
3 1
Output
4
Note
The final results' table for the first sample is:
* 1-3 places β 4 solved problems, the penalty time equals 10
* 4 place β 3 solved problems, the penalty time equals 20
* 5-6 places β 2 solved problems, the penalty time equals 1
* 7 place β 1 solved problem, the penalty time equals 10
The table shows that the second place is shared by the teams that solved 4 problems with penalty time 10. There are 3 such teams.
The final table for the second sample is:
* 1 place β 5 solved problems, the penalty time equals 3
* 2-5 places β 3 solved problems, the penalty time equals 1
The table shows that the fourth place is shared by the teams that solved 3 problems with penalty time 1. There are 4 such teams. | instruction | 0 | 27,697 | 17 | 55,394 |
Tags: binary search, implementation, sortings
Correct Solution:
```
n,k=map(int,input().split())
a=tuple()
for i in range(n):
x,y=map(int,input().split())
a+=((x,y),)
a=sorted(a,key = lambda x: x[1])
a=a[::-1]
a=sorted(a,key = lambda x: x[0])
a=a[::-1]
c=a.count(a[k-1])
print(c)
``` | output | 1 | 27,697 | 17 | 55,395 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Another programming contest is over. You got hold of the contest's final results table. The table has the following data. For each team we are shown two numbers: the number of problems and the total penalty time. However, for no team we are shown its final place.
You know the rules of comparing the results of two given teams very well. Let's say that team a solved pa problems with total penalty time ta and team b solved pb problems with total penalty time tb. Team a gets a higher place than team b in the end, if it either solved more problems on the contest, or solved the same number of problems but in less total time. In other words, team a gets a higher place than team b in the final results' table if either pa > pb, or pa = pb and ta < tb.
It is considered that the teams that solve the same number of problems with the same penalty time share all corresponding places. More formally, let's say there is a group of x teams that solved the same number of problems with the same penalty time. Let's also say that y teams performed better than the teams from this group. In this case all teams from the group share places y + 1, y + 2, ..., y + x. The teams that performed worse than the teams from this group, get their places in the results table starting from the y + x + 1-th place.
Your task is to count what number of teams from the given list shared the k-th place.
Input
The first line contains two integers n and k (1 β€ k β€ n β€ 50). Then n lines contain the description of the teams: the i-th line contains two integers pi and ti (1 β€ pi, ti β€ 50) β the number of solved problems and the total penalty time of the i-th team, correspondingly. All numbers in the lines are separated by spaces.
Output
In the only line print the sought number of teams that got the k-th place in the final results' table.
Examples
Input
7 2
4 10
4 10
4 10
3 20
2 1
2 1
1 10
Output
3
Input
5 4
3 1
3 1
5 3
3 1
3 1
Output
4
Note
The final results' table for the first sample is:
* 1-3 places β 4 solved problems, the penalty time equals 10
* 4 place β 3 solved problems, the penalty time equals 20
* 5-6 places β 2 solved problems, the penalty time equals 1
* 7 place β 1 solved problem, the penalty time equals 10
The table shows that the second place is shared by the teams that solved 4 problems with penalty time 10. There are 3 such teams.
The final table for the second sample is:
* 1 place β 5 solved problems, the penalty time equals 3
* 2-5 places β 3 solved problems, the penalty time equals 1
The table shows that the fourth place is shared by the teams that solved 3 problems with penalty time 1. There are 4 such teams. | instruction | 0 | 27,698 | 17 | 55,396 |
Tags: binary search, implementation, sortings
Correct Solution:
```
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
##########################################################
#for _ in range(int(input())):
n,x = map(int, input().split())
que=[]
d={}
for i in range(n):
q,p=map(int, input().split())
que.append((q,p))
if q in d:
d[q]+=1
else:
d[q]=1
#que.sort(key=lambda x:)
que.sort(key=lambda x:((x[0]),-x[1]))
que=que[::-1]
r=1
'''for i in range(len(que)):
if que[i]!=que[i-1]:
r+=1'''
var=que[x-1]
#print(var)
print(que.count(var))
``` | output | 1 | 27,698 | 17 | 55,397 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Another programming contest is over. You got hold of the contest's final results table. The table has the following data. For each team we are shown two numbers: the number of problems and the total penalty time. However, for no team we are shown its final place.
You know the rules of comparing the results of two given teams very well. Let's say that team a solved pa problems with total penalty time ta and team b solved pb problems with total penalty time tb. Team a gets a higher place than team b in the end, if it either solved more problems on the contest, or solved the same number of problems but in less total time. In other words, team a gets a higher place than team b in the final results' table if either pa > pb, or pa = pb and ta < tb.
It is considered that the teams that solve the same number of problems with the same penalty time share all corresponding places. More formally, let's say there is a group of x teams that solved the same number of problems with the same penalty time. Let's also say that y teams performed better than the teams from this group. In this case all teams from the group share places y + 1, y + 2, ..., y + x. The teams that performed worse than the teams from this group, get their places in the results table starting from the y + x + 1-th place.
Your task is to count what number of teams from the given list shared the k-th place.
Input
The first line contains two integers n and k (1 β€ k β€ n β€ 50). Then n lines contain the description of the teams: the i-th line contains two integers pi and ti (1 β€ pi, ti β€ 50) β the number of solved problems and the total penalty time of the i-th team, correspondingly. All numbers in the lines are separated by spaces.
Output
In the only line print the sought number of teams that got the k-th place in the final results' table.
Examples
Input
7 2
4 10
4 10
4 10
3 20
2 1
2 1
1 10
Output
3
Input
5 4
3 1
3 1
5 3
3 1
3 1
Output
4
Note
The final results' table for the first sample is:
* 1-3 places β 4 solved problems, the penalty time equals 10
* 4 place β 3 solved problems, the penalty time equals 20
* 5-6 places β 2 solved problems, the penalty time equals 1
* 7 place β 1 solved problem, the penalty time equals 10
The table shows that the second place is shared by the teams that solved 4 problems with penalty time 10. There are 3 such teams.
The final table for the second sample is:
* 1 place β 5 solved problems, the penalty time equals 3
* 2-5 places β 3 solved problems, the penalty time equals 1
The table shows that the fourth place is shared by the teams that solved 3 problems with penalty time 1. There are 4 such teams. | instruction | 0 | 27,699 | 17 | 55,398 |
Tags: binary search, implementation, sortings
Correct Solution:
```
n, k = map(int, input().split())
p = []
t = []
for i in range(n):
pi, ti = map(int, input().split())
p.append(pi)
t.append(ti)
for j in range(len(p)):
if pi > p[j]:
p.insert(j, pi)
p.pop()
t.insert(j, ti)
t.pop()
break
elif pi == p[j]:
if ti <= t[j]:
p.insert(j, pi)
p.pop()
t.insert(j, ti)
t.pop()
break
kp = p[k-1]
kt = t[k-1]
res = 0
for i in range(n):
if p[i] == kp and t[i] == kt:
res+=1
print(res)
``` | output | 1 | 27,699 | 17 | 55,399 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Another programming contest is over. You got hold of the contest's final results table. The table has the following data. For each team we are shown two numbers: the number of problems and the total penalty time. However, for no team we are shown its final place.
You know the rules of comparing the results of two given teams very well. Let's say that team a solved pa problems with total penalty time ta and team b solved pb problems with total penalty time tb. Team a gets a higher place than team b in the end, if it either solved more problems on the contest, or solved the same number of problems but in less total time. In other words, team a gets a higher place than team b in the final results' table if either pa > pb, or pa = pb and ta < tb.
It is considered that the teams that solve the same number of problems with the same penalty time share all corresponding places. More formally, let's say there is a group of x teams that solved the same number of problems with the same penalty time. Let's also say that y teams performed better than the teams from this group. In this case all teams from the group share places y + 1, y + 2, ..., y + x. The teams that performed worse than the teams from this group, get their places in the results table starting from the y + x + 1-th place.
Your task is to count what number of teams from the given list shared the k-th place.
Input
The first line contains two integers n and k (1 β€ k β€ n β€ 50). Then n lines contain the description of the teams: the i-th line contains two integers pi and ti (1 β€ pi, ti β€ 50) β the number of solved problems and the total penalty time of the i-th team, correspondingly. All numbers in the lines are separated by spaces.
Output
In the only line print the sought number of teams that got the k-th place in the final results' table.
Examples
Input
7 2
4 10
4 10
4 10
3 20
2 1
2 1
1 10
Output
3
Input
5 4
3 1
3 1
5 3
3 1
3 1
Output
4
Note
The final results' table for the first sample is:
* 1-3 places β 4 solved problems, the penalty time equals 10
* 4 place β 3 solved problems, the penalty time equals 20
* 5-6 places β 2 solved problems, the penalty time equals 1
* 7 place β 1 solved problem, the penalty time equals 10
The table shows that the second place is shared by the teams that solved 4 problems with penalty time 10. There are 3 such teams.
The final table for the second sample is:
* 1 place β 5 solved problems, the penalty time equals 3
* 2-5 places β 3 solved problems, the penalty time equals 1
The table shows that the fourth place is shared by the teams that solved 3 problems with penalty time 1. There are 4 such teams. | instruction | 0 | 27,700 | 17 | 55,400 |
Tags: binary search, implementation, sortings
Correct Solution:
```
n, k = map(int, input().split())
t = []
for _ in range(n):
x, y = map(int, input().split())
t.append((x, y))
t = sorted(t, key = lambda x: x[1], reverse = True)
t = sorted(t, key = lambda x: x[0])
t.reverse()
compare = t[k-1]
count = 0
for x in t:
if x == compare:
count += 1
elif count > 0:
break
print(count)
``` | output | 1 | 27,700 | 17 | 55,401 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Another programming contest is over. You got hold of the contest's final results table. The table has the following data. For each team we are shown two numbers: the number of problems and the total penalty time. However, for no team we are shown its final place.
You know the rules of comparing the results of two given teams very well. Let's say that team a solved pa problems with total penalty time ta and team b solved pb problems with total penalty time tb. Team a gets a higher place than team b in the end, if it either solved more problems on the contest, or solved the same number of problems but in less total time. In other words, team a gets a higher place than team b in the final results' table if either pa > pb, or pa = pb and ta < tb.
It is considered that the teams that solve the same number of problems with the same penalty time share all corresponding places. More formally, let's say there is a group of x teams that solved the same number of problems with the same penalty time. Let's also say that y teams performed better than the teams from this group. In this case all teams from the group share places y + 1, y + 2, ..., y + x. The teams that performed worse than the teams from this group, get their places in the results table starting from the y + x + 1-th place.
Your task is to count what number of teams from the given list shared the k-th place.
Input
The first line contains two integers n and k (1 β€ k β€ n β€ 50). Then n lines contain the description of the teams: the i-th line contains two integers pi and ti (1 β€ pi, ti β€ 50) β the number of solved problems and the total penalty time of the i-th team, correspondingly. All numbers in the lines are separated by spaces.
Output
In the only line print the sought number of teams that got the k-th place in the final results' table.
Examples
Input
7 2
4 10
4 10
4 10
3 20
2 1
2 1
1 10
Output
3
Input
5 4
3 1
3 1
5 3
3 1
3 1
Output
4
Note
The final results' table for the first sample is:
* 1-3 places β 4 solved problems, the penalty time equals 10
* 4 place β 3 solved problems, the penalty time equals 20
* 5-6 places β 2 solved problems, the penalty time equals 1
* 7 place β 1 solved problem, the penalty time equals 10
The table shows that the second place is shared by the teams that solved 4 problems with penalty time 10. There are 3 such teams.
The final table for the second sample is:
* 1 place β 5 solved problems, the penalty time equals 3
* 2-5 places β 3 solved problems, the penalty time equals 1
The table shows that the fourth place is shared by the teams that solved 3 problems with penalty time 1. There are 4 such teams. | instruction | 0 | 27,701 | 17 | 55,402 |
Tags: binary search, implementation, sortings
Correct Solution:
```
import sys
def quicksort(lista,low,high):
if high-low>0:
p=partition(lista,low,high)
quicksort(lista,low,p-1)
quicksort(lista,p+1,high)
return lista
def partition(lista,low,high):
divider,pivot=low,high
for i in range(low,high):
if lista[i][0]>lista[pivot][0]:
lista[i],lista[divider]=lista[divider],lista[i]
divider+=1
elif lista[i][0]==lista[pivot][0] and lista[i][1]<lista[pivot][1]:
lista[i],lista[divider]=lista[divider],lista[i]
divider+=1
lista[pivot],lista[divider]=lista[divider],lista[pivot]
return divider
def main():
n,k=[int(x)for x in sys.stdin.readline().strip().split()]
lista=[]; k-=1
for i in range(n): lista.append([int(x)for x in sys.stdin.readline().strip().split()])
lista=quicksort(lista,0,n-1)
#n lista=quicksort(lista,0,len(lista)-1)
cont=1
for i in range(k-1,-1,-1):
if lista[i]!=lista[k]: break
cont+=1
for j in range(k+1,n):
if lista[j]!=lista[k]: break
cont+=1
print(cont)
main()
``` | output | 1 | 27,701 | 17 | 55,403 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Another programming contest is over. You got hold of the contest's final results table. The table has the following data. For each team we are shown two numbers: the number of problems and the total penalty time. However, for no team we are shown its final place.
You know the rules of comparing the results of two given teams very well. Let's say that team a solved pa problems with total penalty time ta and team b solved pb problems with total penalty time tb. Team a gets a higher place than team b in the end, if it either solved more problems on the contest, or solved the same number of problems but in less total time. In other words, team a gets a higher place than team b in the final results' table if either pa > pb, or pa = pb and ta < tb.
It is considered that the teams that solve the same number of problems with the same penalty time share all corresponding places. More formally, let's say there is a group of x teams that solved the same number of problems with the same penalty time. Let's also say that y teams performed better than the teams from this group. In this case all teams from the group share places y + 1, y + 2, ..., y + x. The teams that performed worse than the teams from this group, get their places in the results table starting from the y + x + 1-th place.
Your task is to count what number of teams from the given list shared the k-th place.
Input
The first line contains two integers n and k (1 β€ k β€ n β€ 50). Then n lines contain the description of the teams: the i-th line contains two integers pi and ti (1 β€ pi, ti β€ 50) β the number of solved problems and the total penalty time of the i-th team, correspondingly. All numbers in the lines are separated by spaces.
Output
In the only line print the sought number of teams that got the k-th place in the final results' table.
Examples
Input
7 2
4 10
4 10
4 10
3 20
2 1
2 1
1 10
Output
3
Input
5 4
3 1
3 1
5 3
3 1
3 1
Output
4
Note
The final results' table for the first sample is:
* 1-3 places β 4 solved problems, the penalty time equals 10
* 4 place β 3 solved problems, the penalty time equals 20
* 5-6 places β 2 solved problems, the penalty time equals 1
* 7 place β 1 solved problem, the penalty time equals 10
The table shows that the second place is shared by the teams that solved 4 problems with penalty time 10. There are 3 such teams.
The final table for the second sample is:
* 1 place β 5 solved problems, the penalty time equals 3
* 2-5 places β 3 solved problems, the penalty time equals 1
The table shows that the fourth place is shared by the teams that solved 3 problems with penalty time 1. There are 4 such teams. | instruction | 0 | 27,702 | 17 | 55,404 |
Tags: binary search, implementation, sortings
Correct Solution:
```
n,k=map(int,input().split())
l=[]
for i in range(n):
x,y=map(int,input().split())
l.append((x,-y))
l.sort(reverse=True)
#print(l)
#r=l.index(k)
s=k-1
e=k-1
count=0
#print(l[e+1][1])
while(s!=-1 or e!=-1):
if s>=0:
if l[s][0]==l[k-1][0] and l[s][1]==l[k-1][1]:
count=count+1
s=s-1
# print(s)
if s<0:
s=-1
else:
s=-1
if e>=0:
if l[e][0]==l[k-1][0] and l[e][1]==l[k-1][1]:
count=count+1
e=e+1
if e>=n:
e=-1
else:
e=-1
print(count-1)
``` | output | 1 | 27,702 | 17 | 55,405 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Another programming contest is over. You got hold of the contest's final results table. The table has the following data. For each team we are shown two numbers: the number of problems and the total penalty time. However, for no team we are shown its final place.
You know the rules of comparing the results of two given teams very well. Let's say that team a solved pa problems with total penalty time ta and team b solved pb problems with total penalty time tb. Team a gets a higher place than team b in the end, if it either solved more problems on the contest, or solved the same number of problems but in less total time. In other words, team a gets a higher place than team b in the final results' table if either pa > pb, or pa = pb and ta < tb.
It is considered that the teams that solve the same number of problems with the same penalty time share all corresponding places. More formally, let's say there is a group of x teams that solved the same number of problems with the same penalty time. Let's also say that y teams performed better than the teams from this group. In this case all teams from the group share places y + 1, y + 2, ..., y + x. The teams that performed worse than the teams from this group, get their places in the results table starting from the y + x + 1-th place.
Your task is to count what number of teams from the given list shared the k-th place.
Input
The first line contains two integers n and k (1 β€ k β€ n β€ 50). Then n lines contain the description of the teams: the i-th line contains two integers pi and ti (1 β€ pi, ti β€ 50) β the number of solved problems and the total penalty time of the i-th team, correspondingly. All numbers in the lines are separated by spaces.
Output
In the only line print the sought number of teams that got the k-th place in the final results' table.
Examples
Input
7 2
4 10
4 10
4 10
3 20
2 1
2 1
1 10
Output
3
Input
5 4
3 1
3 1
5 3
3 1
3 1
Output
4
Note
The final results' table for the first sample is:
* 1-3 places β 4 solved problems, the penalty time equals 10
* 4 place β 3 solved problems, the penalty time equals 20
* 5-6 places β 2 solved problems, the penalty time equals 1
* 7 place β 1 solved problem, the penalty time equals 10
The table shows that the second place is shared by the teams that solved 4 problems with penalty time 10. There are 3 such teams.
The final table for the second sample is:
* 1 place β 5 solved problems, the penalty time equals 3
* 2-5 places β 3 solved problems, the penalty time equals 1
The table shows that the fourth place is shared by the teams that solved 3 problems with penalty time 1. There are 4 such teams. | instruction | 0 | 27,703 | 17 | 55,406 |
Tags: binary search, implementation, sortings
Correct Solution:
```
from functools import cmp_to_key
def result_comparator(result1, result2):
if result1[0] > result2[0]:
return -1
elif result1[0] == result2[0]:
return result1[1] - result2[1]
else:
return 1
num_teams, required_position = map(int, input().split())
frequencies = dict()
results = list()
for _ in range(num_teams):
result = tuple(map(int, input().split()))
frequencies[result] = frequencies.get(result, 0) + 1
results.append(result)
results.sort(key=cmp_to_key(result_comparator))
required_result = results[required_position - 1]
print(frequencies[required_result])
``` | output | 1 | 27,703 | 17 | 55,407 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Another programming contest is over. You got hold of the contest's final results table. The table has the following data. For each team we are shown two numbers: the number of problems and the total penalty time. However, for no team we are shown its final place.
You know the rules of comparing the results of two given teams very well. Let's say that team a solved pa problems with total penalty time ta and team b solved pb problems with total penalty time tb. Team a gets a higher place than team b in the end, if it either solved more problems on the contest, or solved the same number of problems but in less total time. In other words, team a gets a higher place than team b in the final results' table if either pa > pb, or pa = pb and ta < tb.
It is considered that the teams that solve the same number of problems with the same penalty time share all corresponding places. More formally, let's say there is a group of x teams that solved the same number of problems with the same penalty time. Let's also say that y teams performed better than the teams from this group. In this case all teams from the group share places y + 1, y + 2, ..., y + x. The teams that performed worse than the teams from this group, get their places in the results table starting from the y + x + 1-th place.
Your task is to count what number of teams from the given list shared the k-th place.
Input
The first line contains two integers n and k (1 β€ k β€ n β€ 50). Then n lines contain the description of the teams: the i-th line contains two integers pi and ti (1 β€ pi, ti β€ 50) β the number of solved problems and the total penalty time of the i-th team, correspondingly. All numbers in the lines are separated by spaces.
Output
In the only line print the sought number of teams that got the k-th place in the final results' table.
Examples
Input
7 2
4 10
4 10
4 10
3 20
2 1
2 1
1 10
Output
3
Input
5 4
3 1
3 1
5 3
3 1
3 1
Output
4
Note
The final results' table for the first sample is:
* 1-3 places β 4 solved problems, the penalty time equals 10
* 4 place β 3 solved problems, the penalty time equals 20
* 5-6 places β 2 solved problems, the penalty time equals 1
* 7 place β 1 solved problem, the penalty time equals 10
The table shows that the second place is shared by the teams that solved 4 problems with penalty time 10. There are 3 such teams.
The final table for the second sample is:
* 1 place β 5 solved problems, the penalty time equals 3
* 2-5 places β 3 solved problems, the penalty time equals 1
The table shows that the fourth place is shared by the teams that solved 3 problems with penalty time 1. There are 4 such teams. | instruction | 0 | 27,704 | 17 | 55,408 |
Tags: binary search, implementation, sortings
Correct Solution:
```
def swap1(i):
temp=b[i]
b[i]=b[i+1]
b[i+1]=temp
l = list(map(int, input().rstrip().split()))
b=[]
c=[]
for i in range (l[0]):
a=list(map(int, input().rstrip().split()))
b.append(a)
b.sort(reverse=True)
for j in range(len(b)-1):
for i in range(len(b)-1):
if(b[i][0]==b[i+1][0] and b[i][1]>b[i+1][1]):
swap1(i)
print(b.count(b[l[1]-1]))
``` | output | 1 | 27,704 | 17 | 55,409 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Another programming contest is over. You got hold of the contest's final results table. The table has the following data. For each team we are shown two numbers: the number of problems and the total penalty time. However, for no team we are shown its final place.
You know the rules of comparing the results of two given teams very well. Let's say that team a solved pa problems with total penalty time ta and team b solved pb problems with total penalty time tb. Team a gets a higher place than team b in the end, if it either solved more problems on the contest, or solved the same number of problems but in less total time. In other words, team a gets a higher place than team b in the final results' table if either pa > pb, or pa = pb and ta < tb.
It is considered that the teams that solve the same number of problems with the same penalty time share all corresponding places. More formally, let's say there is a group of x teams that solved the same number of problems with the same penalty time. Let's also say that y teams performed better than the teams from this group. In this case all teams from the group share places y + 1, y + 2, ..., y + x. The teams that performed worse than the teams from this group, get their places in the results table starting from the y + x + 1-th place.
Your task is to count what number of teams from the given list shared the k-th place.
Input
The first line contains two integers n and k (1 β€ k β€ n β€ 50). Then n lines contain the description of the teams: the i-th line contains two integers pi and ti (1 β€ pi, ti β€ 50) β the number of solved problems and the total penalty time of the i-th team, correspondingly. All numbers in the lines are separated by spaces.
Output
In the only line print the sought number of teams that got the k-th place in the final results' table.
Examples
Input
7 2
4 10
4 10
4 10
3 20
2 1
2 1
1 10
Output
3
Input
5 4
3 1
3 1
5 3
3 1
3 1
Output
4
Note
The final results' table for the first sample is:
* 1-3 places β 4 solved problems, the penalty time equals 10
* 4 place β 3 solved problems, the penalty time equals 20
* 5-6 places β 2 solved problems, the penalty time equals 1
* 7 place β 1 solved problem, the penalty time equals 10
The table shows that the second place is shared by the teams that solved 4 problems with penalty time 10. There are 3 such teams.
The final table for the second sample is:
* 1 place β 5 solved problems, the penalty time equals 3
* 2-5 places β 3 solved problems, the penalty time equals 1
The table shows that the fourth place is shared by the teams that solved 3 problems with penalty time 1. There are 4 such teams.
Submitted Solution:
```
n,k=map(int,input().split())
dic={}
for i in range(n):
a,b=map(int,input().split())
c=a*100+(51-b)
if c in dic:
dic[c]+=1
else:
dic[c]=1
count=0
r=sorted(dic.keys())
r.reverse()
for i in r:
if count+dic[i]>=k:
print(dic[i])
break
else:
count+=dic[i]
``` | instruction | 0 | 27,705 | 17 | 55,410 |
Yes | output | 1 | 27,705 | 17 | 55,411 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Another programming contest is over. You got hold of the contest's final results table. The table has the following data. For each team we are shown two numbers: the number of problems and the total penalty time. However, for no team we are shown its final place.
You know the rules of comparing the results of two given teams very well. Let's say that team a solved pa problems with total penalty time ta and team b solved pb problems with total penalty time tb. Team a gets a higher place than team b in the end, if it either solved more problems on the contest, or solved the same number of problems but in less total time. In other words, team a gets a higher place than team b in the final results' table if either pa > pb, or pa = pb and ta < tb.
It is considered that the teams that solve the same number of problems with the same penalty time share all corresponding places. More formally, let's say there is a group of x teams that solved the same number of problems with the same penalty time. Let's also say that y teams performed better than the teams from this group. In this case all teams from the group share places y + 1, y + 2, ..., y + x. The teams that performed worse than the teams from this group, get their places in the results table starting from the y + x + 1-th place.
Your task is to count what number of teams from the given list shared the k-th place.
Input
The first line contains two integers n and k (1 β€ k β€ n β€ 50). Then n lines contain the description of the teams: the i-th line contains two integers pi and ti (1 β€ pi, ti β€ 50) β the number of solved problems and the total penalty time of the i-th team, correspondingly. All numbers in the lines are separated by spaces.
Output
In the only line print the sought number of teams that got the k-th place in the final results' table.
Examples
Input
7 2
4 10
4 10
4 10
3 20
2 1
2 1
1 10
Output
3
Input
5 4
3 1
3 1
5 3
3 1
3 1
Output
4
Note
The final results' table for the first sample is:
* 1-3 places β 4 solved problems, the penalty time equals 10
* 4 place β 3 solved problems, the penalty time equals 20
* 5-6 places β 2 solved problems, the penalty time equals 1
* 7 place β 1 solved problem, the penalty time equals 10
The table shows that the second place is shared by the teams that solved 4 problems with penalty time 10. There are 3 such teams.
The final table for the second sample is:
* 1 place β 5 solved problems, the penalty time equals 3
* 2-5 places β 3 solved problems, the penalty time equals 1
The table shows that the fourth place is shared by the teams that solved 3 problems with penalty time 1. There are 4 such teams.
Submitted Solution:
```
n , k = map(int,input().split())
score = []
for _ in range(n):
p,t = map(int,input().split())
score.append([p,t])
score = sorted(score,key=lambda x:(-x[0],x[1]))
check = score[k-1]
print(score.count(check))
``` | instruction | 0 | 27,706 | 17 | 55,412 |
Yes | output | 1 | 27,706 | 17 | 55,413 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Another programming contest is over. You got hold of the contest's final results table. The table has the following data. For each team we are shown two numbers: the number of problems and the total penalty time. However, for no team we are shown its final place.
You know the rules of comparing the results of two given teams very well. Let's say that team a solved pa problems with total penalty time ta and team b solved pb problems with total penalty time tb. Team a gets a higher place than team b in the end, if it either solved more problems on the contest, or solved the same number of problems but in less total time. In other words, team a gets a higher place than team b in the final results' table if either pa > pb, or pa = pb and ta < tb.
It is considered that the teams that solve the same number of problems with the same penalty time share all corresponding places. More formally, let's say there is a group of x teams that solved the same number of problems with the same penalty time. Let's also say that y teams performed better than the teams from this group. In this case all teams from the group share places y + 1, y + 2, ..., y + x. The teams that performed worse than the teams from this group, get their places in the results table starting from the y + x + 1-th place.
Your task is to count what number of teams from the given list shared the k-th place.
Input
The first line contains two integers n and k (1 β€ k β€ n β€ 50). Then n lines contain the description of the teams: the i-th line contains two integers pi and ti (1 β€ pi, ti β€ 50) β the number of solved problems and the total penalty time of the i-th team, correspondingly. All numbers in the lines are separated by spaces.
Output
In the only line print the sought number of teams that got the k-th place in the final results' table.
Examples
Input
7 2
4 10
4 10
4 10
3 20
2 1
2 1
1 10
Output
3
Input
5 4
3 1
3 1
5 3
3 1
3 1
Output
4
Note
The final results' table for the first sample is:
* 1-3 places β 4 solved problems, the penalty time equals 10
* 4 place β 3 solved problems, the penalty time equals 20
* 5-6 places β 2 solved problems, the penalty time equals 1
* 7 place β 1 solved problem, the penalty time equals 10
The table shows that the second place is shared by the teams that solved 4 problems with penalty time 10. There are 3 such teams.
The final table for the second sample is:
* 1 place β 5 solved problems, the penalty time equals 3
* 2-5 places β 3 solved problems, the penalty time equals 1
The table shows that the fourth place is shared by the teams that solved 3 problems with penalty time 1. There are 4 such teams.
Submitted Solution:
```
t, k = [int(a) for a in input().strip().split()]
l = []
for i in range(t):
n, p = [int(a) for a in input().strip().split()]
l.append(n*100+100-p)
l.sort(reverse=True)
c=0
for i in range(t):
if int(l[k-1]) == int(l[i]):
c += 1
print(c)
``` | instruction | 0 | 27,707 | 17 | 55,414 |
Yes | output | 1 | 27,707 | 17 | 55,415 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Another programming contest is over. You got hold of the contest's final results table. The table has the following data. For each team we are shown two numbers: the number of problems and the total penalty time. However, for no team we are shown its final place.
You know the rules of comparing the results of two given teams very well. Let's say that team a solved pa problems with total penalty time ta and team b solved pb problems with total penalty time tb. Team a gets a higher place than team b in the end, if it either solved more problems on the contest, or solved the same number of problems but in less total time. In other words, team a gets a higher place than team b in the final results' table if either pa > pb, or pa = pb and ta < tb.
It is considered that the teams that solve the same number of problems with the same penalty time share all corresponding places. More formally, let's say there is a group of x teams that solved the same number of problems with the same penalty time. Let's also say that y teams performed better than the teams from this group. In this case all teams from the group share places y + 1, y + 2, ..., y + x. The teams that performed worse than the teams from this group, get their places in the results table starting from the y + x + 1-th place.
Your task is to count what number of teams from the given list shared the k-th place.
Input
The first line contains two integers n and k (1 β€ k β€ n β€ 50). Then n lines contain the description of the teams: the i-th line contains two integers pi and ti (1 β€ pi, ti β€ 50) β the number of solved problems and the total penalty time of the i-th team, correspondingly. All numbers in the lines are separated by spaces.
Output
In the only line print the sought number of teams that got the k-th place in the final results' table.
Examples
Input
7 2
4 10
4 10
4 10
3 20
2 1
2 1
1 10
Output
3
Input
5 4
3 1
3 1
5 3
3 1
3 1
Output
4
Note
The final results' table for the first sample is:
* 1-3 places β 4 solved problems, the penalty time equals 10
* 4 place β 3 solved problems, the penalty time equals 20
* 5-6 places β 2 solved problems, the penalty time equals 1
* 7 place β 1 solved problem, the penalty time equals 10
The table shows that the second place is shared by the teams that solved 4 problems with penalty time 10. There are 3 such teams.
The final table for the second sample is:
* 1 place β 5 solved problems, the penalty time equals 3
* 2-5 places β 3 solved problems, the penalty time equals 1
The table shows that the fourth place is shared by the teams that solved 3 problems with penalty time 1. There are 4 such teams.
Submitted Solution:
```
import sys
def quicksort(lista,low,high):
if high-low>0:
p=partition(lista,low,high)
quicksort(lista,low,p-1)
quicksort(lista,p+1,high)
return lista
def partition(lista,low,high):
divider,pivot=low,high
for i in range(low,high):
if lista[i][0]>lista[pivot][0]:
lista[i],lista[divider]=lista[divider],lista[i]
divider+=1
elif lista[i][0]==lista[pivot][0] and lista[i][1]<lista[pivot][1]:
lista[i],lista[divider]=lista[divider],lista[i]
divider+=1
lista[pivot],lista[divider]=lista[divider],lista[pivot]
return divider
def main():
n,k=[int(x)for x in sys.stdin.readline().strip().split()]
lista=[]; k-=1
for i in range(n): lista.append([int(x)for x in sys.stdin.readline().strip().split()])
lista=quicksort(lista,0,n-1)
#n lista=quicksort(lista,0,len(lista)-1)
l,r=k,k
while l>0 and lista[l-1]==lista[k]: l-=1
while r+1<n and lista[r+1]==lista[k]: r+=1
print(r-l+1)
main()
``` | instruction | 0 | 27,708 | 17 | 55,416 |
Yes | output | 1 | 27,708 | 17 | 55,417 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Another programming contest is over. You got hold of the contest's final results table. The table has the following data. For each team we are shown two numbers: the number of problems and the total penalty time. However, for no team we are shown its final place.
You know the rules of comparing the results of two given teams very well. Let's say that team a solved pa problems with total penalty time ta and team b solved pb problems with total penalty time tb. Team a gets a higher place than team b in the end, if it either solved more problems on the contest, or solved the same number of problems but in less total time. In other words, team a gets a higher place than team b in the final results' table if either pa > pb, or pa = pb and ta < tb.
It is considered that the teams that solve the same number of problems with the same penalty time share all corresponding places. More formally, let's say there is a group of x teams that solved the same number of problems with the same penalty time. Let's also say that y teams performed better than the teams from this group. In this case all teams from the group share places y + 1, y + 2, ..., y + x. The teams that performed worse than the teams from this group, get their places in the results table starting from the y + x + 1-th place.
Your task is to count what number of teams from the given list shared the k-th place.
Input
The first line contains two integers n and k (1 β€ k β€ n β€ 50). Then n lines contain the description of the teams: the i-th line contains two integers pi and ti (1 β€ pi, ti β€ 50) β the number of solved problems and the total penalty time of the i-th team, correspondingly. All numbers in the lines are separated by spaces.
Output
In the only line print the sought number of teams that got the k-th place in the final results' table.
Examples
Input
7 2
4 10
4 10
4 10
3 20
2 1
2 1
1 10
Output
3
Input
5 4
3 1
3 1
5 3
3 1
3 1
Output
4
Note
The final results' table for the first sample is:
* 1-3 places β 4 solved problems, the penalty time equals 10
* 4 place β 3 solved problems, the penalty time equals 20
* 5-6 places β 2 solved problems, the penalty time equals 1
* 7 place β 1 solved problem, the penalty time equals 10
The table shows that the second place is shared by the teams that solved 4 problems with penalty time 10. There are 3 such teams.
The final table for the second sample is:
* 1 place β 5 solved problems, the penalty time equals 3
* 2-5 places β 3 solved problems, the penalty time equals 1
The table shows that the fourth place is shared by the teams that solved 3 problems with penalty time 1. There are 4 such teams.
Submitted Solution:
```
n, k = map(int, input().split())
ranking = {}
for _ in range(n):
a, b = map(int, input().split())
if (a, b) in ranking:
ranking[(a, b)] += 1
else:
ranking[(a, b)] = 1
tab = list(ranking.values())
result = 0
s = 0
for e in tab:
if s + e < k - 1:
s += e
else:
result = e
break
print(result)
``` | instruction | 0 | 27,709 | 17 | 55,418 |
No | output | 1 | 27,709 | 17 | 55,419 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Another programming contest is over. You got hold of the contest's final results table. The table has the following data. For each team we are shown two numbers: the number of problems and the total penalty time. However, for no team we are shown its final place.
You know the rules of comparing the results of two given teams very well. Let's say that team a solved pa problems with total penalty time ta and team b solved pb problems with total penalty time tb. Team a gets a higher place than team b in the end, if it either solved more problems on the contest, or solved the same number of problems but in less total time. In other words, team a gets a higher place than team b in the final results' table if either pa > pb, or pa = pb and ta < tb.
It is considered that the teams that solve the same number of problems with the same penalty time share all corresponding places. More formally, let's say there is a group of x teams that solved the same number of problems with the same penalty time. Let's also say that y teams performed better than the teams from this group. In this case all teams from the group share places y + 1, y + 2, ..., y + x. The teams that performed worse than the teams from this group, get their places in the results table starting from the y + x + 1-th place.
Your task is to count what number of teams from the given list shared the k-th place.
Input
The first line contains two integers n and k (1 β€ k β€ n β€ 50). Then n lines contain the description of the teams: the i-th line contains two integers pi and ti (1 β€ pi, ti β€ 50) β the number of solved problems and the total penalty time of the i-th team, correspondingly. All numbers in the lines are separated by spaces.
Output
In the only line print the sought number of teams that got the k-th place in the final results' table.
Examples
Input
7 2
4 10
4 10
4 10
3 20
2 1
2 1
1 10
Output
3
Input
5 4
3 1
3 1
5 3
3 1
3 1
Output
4
Note
The final results' table for the first sample is:
* 1-3 places β 4 solved problems, the penalty time equals 10
* 4 place β 3 solved problems, the penalty time equals 20
* 5-6 places β 2 solved problems, the penalty time equals 1
* 7 place β 1 solved problem, the penalty time equals 10
The table shows that the second place is shared by the teams that solved 4 problems with penalty time 10. There are 3 such teams.
The final table for the second sample is:
* 1 place β 5 solved problems, the penalty time equals 3
* 2-5 places β 3 solved problems, the penalty time equals 1
The table shows that the fourth place is shared by the teams that solved 3 problems with penalty time 1. There are 4 such teams.
Submitted Solution:
```
#------------------------------warmup----------------------------
# *******************************
# * AUTHOR: RAJDEEP GHOSH *
# * NICK : Rajdeep2k *
# * INSTITUTION: IIEST, SHIBPUR *
# *******************************
import os
import sys
from io import BytesIO, IOBase
import math
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
#-------------------game starts now---------------------------------------------------
a,b=map(int,input().split())
nl=list()
for _ in range(a):
x,y=map(int,input().split())
nl.append(x*y)
nl.sort(reverse=True)
c=nl[b]
ans=0
# print(c)
for i in range(a):
if nl[i]==c:
ans+=1
print(ans)
``` | instruction | 0 | 27,710 | 17 | 55,420 |
No | output | 1 | 27,710 | 17 | 55,421 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Another programming contest is over. You got hold of the contest's final results table. The table has the following data. For each team we are shown two numbers: the number of problems and the total penalty time. However, for no team we are shown its final place.
You know the rules of comparing the results of two given teams very well. Let's say that team a solved pa problems with total penalty time ta and team b solved pb problems with total penalty time tb. Team a gets a higher place than team b in the end, if it either solved more problems on the contest, or solved the same number of problems but in less total time. In other words, team a gets a higher place than team b in the final results' table if either pa > pb, or pa = pb and ta < tb.
It is considered that the teams that solve the same number of problems with the same penalty time share all corresponding places. More formally, let's say there is a group of x teams that solved the same number of problems with the same penalty time. Let's also say that y teams performed better than the teams from this group. In this case all teams from the group share places y + 1, y + 2, ..., y + x. The teams that performed worse than the teams from this group, get their places in the results table starting from the y + x + 1-th place.
Your task is to count what number of teams from the given list shared the k-th place.
Input
The first line contains two integers n and k (1 β€ k β€ n β€ 50). Then n lines contain the description of the teams: the i-th line contains two integers pi and ti (1 β€ pi, ti β€ 50) β the number of solved problems and the total penalty time of the i-th team, correspondingly. All numbers in the lines are separated by spaces.
Output
In the only line print the sought number of teams that got the k-th place in the final results' table.
Examples
Input
7 2
4 10
4 10
4 10
3 20
2 1
2 1
1 10
Output
3
Input
5 4
3 1
3 1
5 3
3 1
3 1
Output
4
Note
The final results' table for the first sample is:
* 1-3 places β 4 solved problems, the penalty time equals 10
* 4 place β 3 solved problems, the penalty time equals 20
* 5-6 places β 2 solved problems, the penalty time equals 1
* 7 place β 1 solved problem, the penalty time equals 10
The table shows that the second place is shared by the teams that solved 4 problems with penalty time 10. There are 3 such teams.
The final table for the second sample is:
* 1 place β 5 solved problems, the penalty time equals 3
* 2-5 places β 3 solved problems, the penalty time equals 1
The table shows that the fourth place is shared by the teams that solved 3 problems with penalty time 1. There are 4 such teams.
Submitted Solution:
```
def sol(a,n,k):
if k == 22:
return 1
dp = {}
counter = 1
place = 1
tmp = a[0]
print(a)
for i in range(1,n):
if a[i][0] == tmp[0] and a[i][1] == tmp[1]:
counter+=1
else:
tmp = a[i]
dp[place] = counter
place+=counter
counter = 1
dp[place] = counter
print(dp)
for key,val in dp.items():
if k >= key and k < key+val:
return val
n,k = map(int,input().split())
teams = []
for _ in range(n):
teams.append(tuple(map(int,input().split())))
teams.sort(reverse=True)
print(sol(teams,n,k))
``` | instruction | 0 | 27,711 | 17 | 55,422 |
No | output | 1 | 27,711 | 17 | 55,423 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Another programming contest is over. You got hold of the contest's final results table. The table has the following data. For each team we are shown two numbers: the number of problems and the total penalty time. However, for no team we are shown its final place.
You know the rules of comparing the results of two given teams very well. Let's say that team a solved pa problems with total penalty time ta and team b solved pb problems with total penalty time tb. Team a gets a higher place than team b in the end, if it either solved more problems on the contest, or solved the same number of problems but in less total time. In other words, team a gets a higher place than team b in the final results' table if either pa > pb, or pa = pb and ta < tb.
It is considered that the teams that solve the same number of problems with the same penalty time share all corresponding places. More formally, let's say there is a group of x teams that solved the same number of problems with the same penalty time. Let's also say that y teams performed better than the teams from this group. In this case all teams from the group share places y + 1, y + 2, ..., y + x. The teams that performed worse than the teams from this group, get their places in the results table starting from the y + x + 1-th place.
Your task is to count what number of teams from the given list shared the k-th place.
Input
The first line contains two integers n and k (1 β€ k β€ n β€ 50). Then n lines contain the description of the teams: the i-th line contains two integers pi and ti (1 β€ pi, ti β€ 50) β the number of solved problems and the total penalty time of the i-th team, correspondingly. All numbers in the lines are separated by spaces.
Output
In the only line print the sought number of teams that got the k-th place in the final results' table.
Examples
Input
7 2
4 10
4 10
4 10
3 20
2 1
2 1
1 10
Output
3
Input
5 4
3 1
3 1
5 3
3 1
3 1
Output
4
Note
The final results' table for the first sample is:
* 1-3 places β 4 solved problems, the penalty time equals 10
* 4 place β 3 solved problems, the penalty time equals 20
* 5-6 places β 2 solved problems, the penalty time equals 1
* 7 place β 1 solved problem, the penalty time equals 10
The table shows that the second place is shared by the teams that solved 4 problems with penalty time 10. There are 3 such teams.
The final table for the second sample is:
* 1 place β 5 solved problems, the penalty time equals 3
* 2-5 places β 3 solved problems, the penalty time equals 1
The table shows that the fourth place is shared by the teams that solved 3 problems with penalty time 1. There are 4 such teams.
Submitted Solution:
```
ar = []
for i in input().split(' '):
ar.append(int(i))
matrix = []
my_dict = {}
for i in range(ar[0]):
temp = []
for i in input().split(' '):
temp.append(int(i))
matrix.append(temp)
if str(temp[0]) + ' ' + str(temp[1]) in my_dict:
my_dict[str(temp[0]) + ' ' + str(temp[1])] = my_dict[str(temp[0]) + ' ' + str(temp[1])] + 1
else:
my_dict[str(temp[0]) + ' ' + str(temp[1])] = 1
matrix = sorted(matrix,key=lambda x: (x[0],x[1]), reverse = True)
print(my_dict[str(matrix[ar[1] - 1][0]) + ' ' + str(matrix[ar[1] - 1][1])])
``` | instruction | 0 | 27,712 | 17 | 55,424 |
No | output | 1 | 27,712 | 17 | 55,425 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Three swimmers decided to organize a party in the swimming pool! At noon, they started to swim from the left side of the pool.
It takes the first swimmer exactly a minutes to swim across the entire pool and come back, exactly b minutes for the second swimmer and c minutes for the third. Hence, the first swimmer will be on the left side of the pool after 0, a, 2a, 3a, ... minutes after the start time, the second one will be at 0, b, 2b, 3b, ... minutes, and the third one will be on the left side of the pool after 0, c, 2c, 3c, ... minutes.
You came to the left side of the pool exactly p minutes after they started swimming. Determine how long you have to wait before one of the swimmers arrives at the left side of the pool.
Input
The first line of the input contains a single integer t (1 β€ t β€ 1000) β the number of test cases. Next t lines contains test case descriptions, one per line.
Each line contains four integers p, a, b and c (1 β€ p, a, b, c β€ 10^{18}), time in minutes after the start, when you came to the pool and times in minutes it take the swimmers to cross the entire pool and come back.
Output
For each test case, output one integer β how long you have to wait (in minutes) before one of the swimmers arrives at the left side of the pool.
Example
Input
4
9 5 4 8
2 6 10 9
10 2 5 10
10 9 9 9
Output
1
4
0
8
Note
In the first test case, the first swimmer is on the left side in 0, 5, 10, 15, β¦ minutes after the start time, the second swimmer is on the left side in 0, 4, 8, 12, β¦ minutes after the start time, and the third swimmer is on the left side in 0, 8, 16, 24, β¦ minutes after the start time. You arrived at the pool in 9 minutes after the start time and in a minute you will meet the first swimmer on the left side.
In the second test case, the first swimmer is on the left side in 0, 6, 12, 18, β¦ minutes after the start time, the second swimmer is on the left side in 0, 10, 20, 30, β¦ minutes after the start time, and the third swimmer is on the left side in 0, 9, 18, 27, β¦ minutes after the start time. You arrived at the pool 2 minutes after the start time and after 4 minutes meet the first swimmer on the left side.
In the third test case, you came to the pool 10 minutes after the start time. At the same time, all three swimmers are on the left side. A rare stroke of luck!
In the fourth test case, all swimmers are located on the left side in 0, 9, 18, 27, β¦ minutes after the start time. You arrived at the pool 10 minutes after the start time and after 8 minutes meet all three swimmers on the left side.
Submitted Solution:
```
for i in range(0,int(input())):
p,a,b,c=map(int,input().split(' '))
if p%a==0 or p%b==0 or p%c==0:
print(0)
else:
set_1=set()
set_1.update([a-p%a,b-p%b,c-p%c])
print(min(set_1))
``` | instruction | 0 | 28,482 | 17 | 56,964 |
Yes | output | 1 | 28,482 | 17 | 56,965 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Three swimmers decided to organize a party in the swimming pool! At noon, they started to swim from the left side of the pool.
It takes the first swimmer exactly a minutes to swim across the entire pool and come back, exactly b minutes for the second swimmer and c minutes for the third. Hence, the first swimmer will be on the left side of the pool after 0, a, 2a, 3a, ... minutes after the start time, the second one will be at 0, b, 2b, 3b, ... minutes, and the third one will be on the left side of the pool after 0, c, 2c, 3c, ... minutes.
You came to the left side of the pool exactly p minutes after they started swimming. Determine how long you have to wait before one of the swimmers arrives at the left side of the pool.
Input
The first line of the input contains a single integer t (1 β€ t β€ 1000) β the number of test cases. Next t lines contains test case descriptions, one per line.
Each line contains four integers p, a, b and c (1 β€ p, a, b, c β€ 10^{18}), time in minutes after the start, when you came to the pool and times in minutes it take the swimmers to cross the entire pool and come back.
Output
For each test case, output one integer β how long you have to wait (in minutes) before one of the swimmers arrives at the left side of the pool.
Example
Input
4
9 5 4 8
2 6 10 9
10 2 5 10
10 9 9 9
Output
1
4
0
8
Note
In the first test case, the first swimmer is on the left side in 0, 5, 10, 15, β¦ minutes after the start time, the second swimmer is on the left side in 0, 4, 8, 12, β¦ minutes after the start time, and the third swimmer is on the left side in 0, 8, 16, 24, β¦ minutes after the start time. You arrived at the pool in 9 minutes after the start time and in a minute you will meet the first swimmer on the left side.
In the second test case, the first swimmer is on the left side in 0, 6, 12, 18, β¦ minutes after the start time, the second swimmer is on the left side in 0, 10, 20, 30, β¦ minutes after the start time, and the third swimmer is on the left side in 0, 9, 18, 27, β¦ minutes after the start time. You arrived at the pool 2 minutes after the start time and after 4 minutes meet the first swimmer on the left side.
In the third test case, you came to the pool 10 minutes after the start time. At the same time, all three swimmers are on the left side. A rare stroke of luck!
In the fourth test case, all swimmers are located on the left side in 0, 9, 18, 27, β¦ minutes after the start time. You arrived at the pool 10 minutes after the start time and after 8 minutes meet all three swimmers on the left side.
Submitted Solution:
```
import time,math as mt,bisect as bs,sys
from sys import stdin,stdout
from collections import deque
from fractions import Fraction
from collections import Counter
from collections import OrderedDict
from collections import defaultdict
pi=3.14159265358979323846264338327950
def II(): # to take integer input
return int(stdin.readline())
def IP(): # to take tuple as input
return map(int,stdin.readline().split())
def L(): # to take list as input
return list(map(int,stdin.readline().split()))
def P(x): # to print integer,list,string etc..
return stdout.write(str(x)+"\n")
def PI(x,y): # to print tuple separatedly
return stdout.write(str(x)+" "+str(y)+"\n")
def lcm(a,b): # to calculate lcm
return (a*b)//gcd(a,b)
def gcd(a,b): # to calculate gcd
if a==0:
return b
elif b==0:
return a
if a>b:
return gcd(a%b,b)
else:
return gcd(a,b%a)
def bfs(adj,v): # a schema of bfs
visited=[False]*(v+1)
q=deque()
while q:
pass
def setBit(n):
count=0
while n!=0:
n=n&(n-1)
count+=1
return count
mx=10**7
spf=[mx]*(mx+1)
def readTree(n,e): # to read tree
adj=[set() for i in range(n+1)]
for i in range(e):
u1,u2=IP()
adj[u1].add(u2)
return adj
def sieve():
li=[True]*(10**3+5)
li[0],li[1]=False,False
for i in range(2,len(li),1):
if li[i]==True:
for j in range(i*i,len(li),i):
li[j]=False
prime,cur=[0]*200,0
for i in range(10**3+5):
if li[i]==True:
prime[cur]=i
cur+=1
return prime
spf=[1e9 for i in range(10**6+1)]
def SPF():
mx=(10**6+1)
spf[1]=1
for i in range(2,mx):
if spf[i]==1e9:
spf[i]=i
for j in range(i*i,mx,i):
if i<spf[j]:
spf[j]=i
return
def prime(n):
prm=deque()
d={}
while n!=1:
prm.append(spf[n])
n=n//spf[n]
for ele in prm:
d[ele]=d.get(ele,0)+1
return d
#####################################################################################
mod=998244353
inf = 10000000000000000
def solve():
p,a,b,c=L()
ta,tb,tc=p//a,p//b,p//c
if p%a:
ta+=1
if p%b:
tb+=1
if p%c:
tc+=1
print(min(a*ta-p,b*tb-p,c*tc-p))
return
t=II()
for i in range(t):
solve()
#######
#
#
####### # # # #### # # #
# # # # # # # # # # #
# #### # # #### #### # #
###### # # #### # # # # #
# ``````ΒΆ0````1ΒΆ1_```````````````````````````````````````
# ```````ΒΆΒΆΒΆ0_`_ΒΆΒΆΒΆ0011100ΒΆΒΆΒΆΒΆΒΆΒΆΒΆ001_````````````````````
# ````````ΒΆΒΆΒΆΒΆΒΆ00ΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆ0_````````````````
# `````1_``ΒΆΒΆ00ΒΆ0000000000000000000000ΒΆΒΆΒΆΒΆ0_`````````````
# `````_ΒΆΒΆ_`0ΒΆ000000000000000000000000000ΒΆΒΆΒΆΒΆΒΆ1``````````
# ```````ΒΆΒΆΒΆ00ΒΆ00000000000000000000000000000ΒΆΒΆΒΆ_`````````
# ````````_ΒΆΒΆ00000000000000000000ΒΆΒΆ00000000000ΒΆΒΆ`````````
# `````_0011ΒΆΒΆΒΆΒΆΒΆ000000000000ΒΆΒΆ00ΒΆΒΆ0ΒΆΒΆ00000000ΒΆΒΆ_````````
# ```````_ΒΆΒΆΒΆΒΆΒΆΒΆΒΆ00000000000ΒΆΒΆΒΆΒΆ0ΒΆΒΆΒΆΒΆΒΆ00000000ΒΆΒΆ1````````
# ``````````1ΒΆΒΆΒΆΒΆΒΆ000000ΒΆΒΆ0ΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆ0000000ΒΆΒΆΒΆ````````
# ```````````ΒΆΒΆΒΆ0ΒΆ000ΒΆ00ΒΆ0ΒΆΒΆ`_____`__1ΒΆ0ΒΆΒΆ00ΒΆ00ΒΆΒΆ````````
# ```````````ΒΆΒΆΒΆΒΆΒΆ00ΒΆ00ΒΆ10ΒΆ0``_1111_`_ΒΆΒΆ0000ΒΆ0ΒΆΒΆΒΆ````````
# ``````````1ΒΆΒΆΒΆΒΆΒΆ00ΒΆ0ΒΆΒΆ_ΒΆΒΆ1`_ΒΆ_1_0_`1ΒΆΒΆ_0ΒΆ0ΒΆΒΆ0ΒΆΒΆ````````
# ````````1ΒΆΒΆΒΆΒΆΒΆΒΆΒΆ0ΒΆΒΆ0ΒΆ0_0ΒΆ``100111``_ΒΆ1_0ΒΆ0ΒΆΒΆ_1ΒΆ````````
# ```````1ΒΆΒΆΒΆΒΆ00ΒΆΒΆΒΆΒΆΒΆΒΆΒΆ010ΒΆ``1111111_0ΒΆ11ΒΆΒΆΒΆΒΆΒΆ_10````````
# ```````0ΒΆΒΆΒΆΒΆ__10ΒΆΒΆΒΆΒΆΒΆ100ΒΆΒΆΒΆ0111110ΒΆΒΆΒΆ1__ΒΆΒΆΒΆΒΆ`__````````
# ```````ΒΆΒΆΒΆΒΆ0`__0ΒΆΒΆ0ΒΆΒΆ_ΒΆΒΆΒΆ_11````_0ΒΆΒΆ0`_1ΒΆΒΆΒΆΒΆ```````````
# ```````ΒΆΒΆΒΆ00`__0ΒΆΒΆ_00`_0_``````````1_``ΒΆ0ΒΆΒΆ_```````````
# ``````1ΒΆ1``ΒΆΒΆ``1ΒΆΒΆ_11``````````````````ΒΆ`ΒΆΒΆ````````````
# ``````1_``ΒΆ0_ΒΆ1`0ΒΆ_`_``````````_``````1_`ΒΆ1````````````
# ``````````_`1ΒΆ00ΒΆΒΆ_````_````__`1`````__`_ΒΆ`````````````
# ````````````ΒΆ1`0ΒΆΒΆ_`````````_11_`````_``_``````````````
# `````````ΒΆΒΆΒΆΒΆ000ΒΆΒΆ_1```````_____```_1``````````````````
# `````````ΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆ0_``````_````_1111__``````````````
# `````````ΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆ01_`````_11____1111_```````````
# `````````ΒΆΒΆ0ΒΆ0ΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆ1101_______11ΒΆ_```````````
# ``````_ΒΆΒΆΒΆ0000000ΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆ0ΒΆ0ΒΆΒΆΒΆ1````````````
# `````0ΒΆΒΆ0000000ΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆ1`````````````
# ````0ΒΆ0000000ΒΆΒΆ0_````_011_10ΒΆ110ΒΆ01_1ΒΆΒΆΒΆ0````_100ΒΆ001_`
# ```1ΒΆ0000000ΒΆ0_``__`````````_`````````0ΒΆ_``_00ΒΆΒΆ010ΒΆ001
# ```ΒΆΒΆ00000ΒΆΒΆ1``_01``_11____``1_``_`````ΒΆΒΆ0100ΒΆ1```_00ΒΆ1
# ``1ΒΆΒΆ00000ΒΆ_``_ΒΆ_`_101_``_`__````__````_0000001100ΒΆΒΆΒΆ0`
# ``ΒΆΒΆΒΆ0000ΒΆ1_`_ΒΆ``__0_``````_1````_1_````1ΒΆΒΆΒΆ0ΒΆΒΆΒΆΒΆΒΆΒΆ0```
# `_ΒΆΒΆΒΆΒΆ00ΒΆ0___01_10ΒΆ_``__````1`````11___`1ΒΆΒΆΒΆ01_````````
# `1ΒΆΒΆΒΆΒΆΒΆ0ΒΆ0`__01ΒΆΒΆΒΆ0````1_```11``___1_1__11ΒΆ000`````````
# `1ΒΆΒΆΒΆΒΆΒΆΒΆΒΆ1_1_01__`01```_1```_1__1_11___1_``00ΒΆ1````````
# ``ΒΆΒΆΒΆΒΆΒΆΒΆΒΆ0`__10__000````1____1____1___1_```10ΒΆ0_```````
# ``0ΒΆΒΆΒΆΒΆΒΆΒΆΒΆ1___0000000```11___1__`_0111_```000ΒΆ01```````
# ```ΒΆΒΆΒΆ00000ΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆ01___1___00_1ΒΆΒΆΒΆ`_``1ΒΆΒΆ10ΒΆΒΆ0```````
# ```1010000ΒΆ000ΒΆΒΆ0100_11__1011000ΒΆΒΆ0ΒΆ1_10ΒΆΒΆΒΆ_0ΒΆΒΆ00``````
# 10ΒΆ000000000ΒΆ0________0ΒΆ000000ΒΆΒΆ0000ΒΆΒΆΒΆΒΆ000_0ΒΆ0ΒΆ00`````
# ΒΆΒΆΒΆΒΆΒΆΒΆ0000ΒΆΒΆΒΆΒΆ_`___`_0ΒΆΒΆΒΆΒΆΒΆΒΆΒΆ00000000000000_0ΒΆ00ΒΆ01````
# ΒΆΒΆΒΆΒΆΒΆ0ΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆ_``_1ΒΆΒΆΒΆ00000000000000000000_0ΒΆ000ΒΆ01```
# 1__```1ΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆ00ΒΆΒΆΒΆΒΆ00000000000000000000ΒΆ_0ΒΆ0000ΒΆ0_``
# ```````ΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆ00000000000000000000010ΒΆ00000ΒΆΒΆ_`
# ```````0ΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆ00000000000000000000ΒΆ10ΒΆΒΆ0ΒΆΒΆΒΆΒΆΒΆ0`
# ````````ΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆ0ΒΆΒΆΒΆ00000000000000000000010ΒΆΒΆΒΆ0011```
# ````````1ΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆ0ΒΆΒΆΒΆ0000000000000000000ΒΆ100__1_`````
# `````````ΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆ000000000000000000ΒΆ11``_1``````
# `````````1ΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆ0ΒΆΒΆΒΆ00000000000000000ΒΆ11___1_`````
# ``````````ΒΆΒΆΒΆΒΆΒΆΒΆ0ΒΆ0ΒΆΒΆΒΆΒΆΒΆΒΆΒΆ0000000000000000ΒΆ11__``1_````
# ``````````ΒΆΒΆΒΆΒΆΒΆΒΆΒΆ0ΒΆΒΆΒΆ0ΒΆΒΆΒΆΒΆΒΆ000000000000000ΒΆ1__````__```
# ``````````ΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆ0ΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆ0000000000000000__`````11``
# `````````_ΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆ000ΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆ000000000000011_``_1ΒΆΒΆΒΆ0`
# `````````_ΒΆΒΆΒΆΒΆΒΆΒΆ0ΒΆΒΆ000000ΒΆΒΆΒΆΒΆΒΆΒΆΒΆ000000000000100ΒΆΒΆΒΆΒΆ0_`_
# `````````1ΒΆΒΆΒΆΒΆΒΆ0ΒΆΒΆΒΆ000000000ΒΆΒΆΒΆΒΆΒΆΒΆ000000000ΒΆ00ΒΆΒΆ01`````
# `````````ΒΆΒΆΒΆΒΆΒΆ0ΒΆ0ΒΆΒΆΒΆ0000000000000ΒΆ0ΒΆ00000000011_``````_
# ````````1ΒΆΒΆ0ΒΆΒΆΒΆ0ΒΆΒΆΒΆΒΆΒΆΒΆΒΆ000000000000000000000ΒΆ11___11111
# ````````ΒΆΒΆΒΆΒΆ0ΒΆΒΆΒΆΒΆΒΆ00ΒΆΒΆΒΆΒΆΒΆΒΆ000000000000000000ΒΆ011111111_
# ```````_ΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆ0000000ΒΆ0ΒΆ00000000000000000ΒΆ01_1111111
# ```````0ΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆ000000000000000000000000000ΒΆ01___`````
# ```````ΒΆΒΆΒΆΒΆΒΆΒΆ0ΒΆΒΆΒΆ000000000000000000000000000ΒΆ01___1````
# ``````_ΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆ00000000000000000000000000000011_111```
# ``````0ΒΆΒΆ0ΒΆΒΆΒΆ0ΒΆΒΆ0000000000000000000000000000ΒΆ01`1_11_``
# ``````ΒΆΒΆΒΆΒΆΒΆΒΆ0ΒΆΒΆΒΆ0000000000000000000000000000001`_0_11_`
# ``````ΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆΒΆ00000000000000000000000000000ΒΆ01``_0_11`
# ``````ΒΆΒΆΒΆΒΆ0ΒΆΒΆΒΆΒΆ00000000000000000000000000000001```_1_11
``` | instruction | 0 | 28,483 | 17 | 56,966 |
Yes | output | 1 | 28,483 | 17 | 56,967 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Three swimmers decided to organize a party in the swimming pool! At noon, they started to swim from the left side of the pool.
It takes the first swimmer exactly a minutes to swim across the entire pool and come back, exactly b minutes for the second swimmer and c minutes for the third. Hence, the first swimmer will be on the left side of the pool after 0, a, 2a, 3a, ... minutes after the start time, the second one will be at 0, b, 2b, 3b, ... minutes, and the third one will be on the left side of the pool after 0, c, 2c, 3c, ... minutes.
You came to the left side of the pool exactly p minutes after they started swimming. Determine how long you have to wait before one of the swimmers arrives at the left side of the pool.
Input
The first line of the input contains a single integer t (1 β€ t β€ 1000) β the number of test cases. Next t lines contains test case descriptions, one per line.
Each line contains four integers p, a, b and c (1 β€ p, a, b, c β€ 10^{18}), time in minutes after the start, when you came to the pool and times in minutes it take the swimmers to cross the entire pool and come back.
Output
For each test case, output one integer β how long you have to wait (in minutes) before one of the swimmers arrives at the left side of the pool.
Example
Input
4
9 5 4 8
2 6 10 9
10 2 5 10
10 9 9 9
Output
1
4
0
8
Note
In the first test case, the first swimmer is on the left side in 0, 5, 10, 15, β¦ minutes after the start time, the second swimmer is on the left side in 0, 4, 8, 12, β¦ minutes after the start time, and the third swimmer is on the left side in 0, 8, 16, 24, β¦ minutes after the start time. You arrived at the pool in 9 minutes after the start time and in a minute you will meet the first swimmer on the left side.
In the second test case, the first swimmer is on the left side in 0, 6, 12, 18, β¦ minutes after the start time, the second swimmer is on the left side in 0, 10, 20, 30, β¦ minutes after the start time, and the third swimmer is on the left side in 0, 9, 18, 27, β¦ minutes after the start time. You arrived at the pool 2 minutes after the start time and after 4 minutes meet the first swimmer on the left side.
In the third test case, you came to the pool 10 minutes after the start time. At the same time, all three swimmers are on the left side. A rare stroke of luck!
In the fourth test case, all swimmers are located on the left side in 0, 9, 18, 27, β¦ minutes after the start time. You arrived at the pool 10 minutes after the start time and after 8 minutes meet all three swimmers on the left side.
Submitted Solution:
```
# -*- coding: utf-8 -*-
"""
Created on Sat Mar 6 18:30:17 2021
@author: DELL
"""
#import math
for _ in range(int(input())):
p , a , b , c = map(int , input().split())
a1 = p // a
if p % a != 0:
a1 += 1
b1 = p // b
if p % b != 0:
b1 += 1
c1 = p // c
if p % c != 0:
c1 += 1
#print(min(math.ceil(p / a) * a, math.ceil(p / b) * b, math.ceil(p / c) * c) - p)
#print(math.ceil(p/a) )
#print(1000000000000000000 / 999999999999999999)
print(min(a1 * a, b1 * b, c1 * c) - p)
``` | instruction | 0 | 28,484 | 17 | 56,968 |
Yes | output | 1 | 28,484 | 17 | 56,969 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Three swimmers decided to organize a party in the swimming pool! At noon, they started to swim from the left side of the pool.
It takes the first swimmer exactly a minutes to swim across the entire pool and come back, exactly b minutes for the second swimmer and c minutes for the third. Hence, the first swimmer will be on the left side of the pool after 0, a, 2a, 3a, ... minutes after the start time, the second one will be at 0, b, 2b, 3b, ... minutes, and the third one will be on the left side of the pool after 0, c, 2c, 3c, ... minutes.
You came to the left side of the pool exactly p minutes after they started swimming. Determine how long you have to wait before one of the swimmers arrives at the left side of the pool.
Input
The first line of the input contains a single integer t (1 β€ t β€ 1000) β the number of test cases. Next t lines contains test case descriptions, one per line.
Each line contains four integers p, a, b and c (1 β€ p, a, b, c β€ 10^{18}), time in minutes after the start, when you came to the pool and times in minutes it take the swimmers to cross the entire pool and come back.
Output
For each test case, output one integer β how long you have to wait (in minutes) before one of the swimmers arrives at the left side of the pool.
Example
Input
4
9 5 4 8
2 6 10 9
10 2 5 10
10 9 9 9
Output
1
4
0
8
Note
In the first test case, the first swimmer is on the left side in 0, 5, 10, 15, β¦ minutes after the start time, the second swimmer is on the left side in 0, 4, 8, 12, β¦ minutes after the start time, and the third swimmer is on the left side in 0, 8, 16, 24, β¦ minutes after the start time. You arrived at the pool in 9 minutes after the start time and in a minute you will meet the first swimmer on the left side.
In the second test case, the first swimmer is on the left side in 0, 6, 12, 18, β¦ minutes after the start time, the second swimmer is on the left side in 0, 10, 20, 30, β¦ minutes after the start time, and the third swimmer is on the left side in 0, 9, 18, 27, β¦ minutes after the start time. You arrived at the pool 2 minutes after the start time and after 4 minutes meet the first swimmer on the left side.
In the third test case, you came to the pool 10 minutes after the start time. At the same time, all three swimmers are on the left side. A rare stroke of luck!
In the fourth test case, all swimmers are located on the left side in 0, 9, 18, 27, β¦ minutes after the start time. You arrived at the pool 10 minutes after the start time and after 8 minutes meet all three swimmers on the left side.
Submitted Solution:
```
# print("Become the programmer you're meant to be!")
try:
t = int(input())
while(t != 0):
p,a,b,c = (map(int,input().split()))
if p%a==0 or p%b == 0 or p%c ==0:
print(0)
else:
print(min(min(a - (p%a) , b - (p%b)) , c - (p%c)))
t -= 1
except EOFError:
print(" ")
``` | instruction | 0 | 28,485 | 17 | 56,970 |
Yes | output | 1 | 28,485 | 17 | 56,971 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Three swimmers decided to organize a party in the swimming pool! At noon, they started to swim from the left side of the pool.
It takes the first swimmer exactly a minutes to swim across the entire pool and come back, exactly b minutes for the second swimmer and c minutes for the third. Hence, the first swimmer will be on the left side of the pool after 0, a, 2a, 3a, ... minutes after the start time, the second one will be at 0, b, 2b, 3b, ... minutes, and the third one will be on the left side of the pool after 0, c, 2c, 3c, ... minutes.
You came to the left side of the pool exactly p minutes after they started swimming. Determine how long you have to wait before one of the swimmers arrives at the left side of the pool.
Input
The first line of the input contains a single integer t (1 β€ t β€ 1000) β the number of test cases. Next t lines contains test case descriptions, one per line.
Each line contains four integers p, a, b and c (1 β€ p, a, b, c β€ 10^{18}), time in minutes after the start, when you came to the pool and times in minutes it take the swimmers to cross the entire pool and come back.
Output
For each test case, output one integer β how long you have to wait (in minutes) before one of the swimmers arrives at the left side of the pool.
Example
Input
4
9 5 4 8
2 6 10 9
10 2 5 10
10 9 9 9
Output
1
4
0
8
Note
In the first test case, the first swimmer is on the left side in 0, 5, 10, 15, β¦ minutes after the start time, the second swimmer is on the left side in 0, 4, 8, 12, β¦ minutes after the start time, and the third swimmer is on the left side in 0, 8, 16, 24, β¦ minutes after the start time. You arrived at the pool in 9 minutes after the start time and in a minute you will meet the first swimmer on the left side.
In the second test case, the first swimmer is on the left side in 0, 6, 12, 18, β¦ minutes after the start time, the second swimmer is on the left side in 0, 10, 20, 30, β¦ minutes after the start time, and the third swimmer is on the left side in 0, 9, 18, 27, β¦ minutes after the start time. You arrived at the pool 2 minutes after the start time and after 4 minutes meet the first swimmer on the left side.
In the third test case, you came to the pool 10 minutes after the start time. At the same time, all three swimmers are on the left side. A rare stroke of luck!
In the fourth test case, all swimmers are located on the left side in 0, 9, 18, 27, β¦ minutes after the start time. You arrived at the pool 10 minutes after the start time and after 8 minutes meet all three swimmers on the left side.
Submitted Solution:
```
a=int(input())
p=[]
for i in range(a):
b,c,d,e=map(int,input().split())
cc=b//c
dd=b//d
ee=b//e
if b/c>int(b/c):
cc=b//c+1
if b/d>int(b/d):
dd=b//d+1
if b/e> int(b/e):
ee=b//e+1
cc=cc*c
dd=dd*d
ee=ee*e
l=[cc,dd,ee]
f=min(l)
p.append(f-b)
for j in range(len(p)):
print(p[j])
``` | instruction | 0 | 28,486 | 17 | 56,972 |
No | output | 1 | 28,486 | 17 | 56,973 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Three swimmers decided to organize a party in the swimming pool! At noon, they started to swim from the left side of the pool.
It takes the first swimmer exactly a minutes to swim across the entire pool and come back, exactly b minutes for the second swimmer and c minutes for the third. Hence, the first swimmer will be on the left side of the pool after 0, a, 2a, 3a, ... minutes after the start time, the second one will be at 0, b, 2b, 3b, ... minutes, and the third one will be on the left side of the pool after 0, c, 2c, 3c, ... minutes.
You came to the left side of the pool exactly p minutes after they started swimming. Determine how long you have to wait before one of the swimmers arrives at the left side of the pool.
Input
The first line of the input contains a single integer t (1 β€ t β€ 1000) β the number of test cases. Next t lines contains test case descriptions, one per line.
Each line contains four integers p, a, b and c (1 β€ p, a, b, c β€ 10^{18}), time in minutes after the start, when you came to the pool and times in minutes it take the swimmers to cross the entire pool and come back.
Output
For each test case, output one integer β how long you have to wait (in minutes) before one of the swimmers arrives at the left side of the pool.
Example
Input
4
9 5 4 8
2 6 10 9
10 2 5 10
10 9 9 9
Output
1
4
0
8
Note
In the first test case, the first swimmer is on the left side in 0, 5, 10, 15, β¦ minutes after the start time, the second swimmer is on the left side in 0, 4, 8, 12, β¦ minutes after the start time, and the third swimmer is on the left side in 0, 8, 16, 24, β¦ minutes after the start time. You arrived at the pool in 9 minutes after the start time and in a minute you will meet the first swimmer on the left side.
In the second test case, the first swimmer is on the left side in 0, 6, 12, 18, β¦ minutes after the start time, the second swimmer is on the left side in 0, 10, 20, 30, β¦ minutes after the start time, and the third swimmer is on the left side in 0, 9, 18, 27, β¦ minutes after the start time. You arrived at the pool 2 minutes after the start time and after 4 minutes meet the first swimmer on the left side.
In the third test case, you came to the pool 10 minutes after the start time. At the same time, all three swimmers are on the left side. A rare stroke of luck!
In the fourth test case, all swimmers are located on the left side in 0, 9, 18, 27, β¦ minutes after the start time. You arrived at the pool 10 minutes after the start time and after 8 minutes meet all three swimmers on the left side.
Submitted Solution:
```
import math
for _ in range(int(input())):
p, a, b, c = list(map(int, input().split()))
a = math.ceil(p/a)*a
b = math.ceil(p/b)*b
c = math.ceil(p/c)*c
# print(a,b,c)
ans = min(a,b,c)-p
print(ans)
``` | instruction | 0 | 28,487 | 17 | 56,974 |
No | output | 1 | 28,487 | 17 | 56,975 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Three swimmers decided to organize a party in the swimming pool! At noon, they started to swim from the left side of the pool.
It takes the first swimmer exactly a minutes to swim across the entire pool and come back, exactly b minutes for the second swimmer and c minutes for the third. Hence, the first swimmer will be on the left side of the pool after 0, a, 2a, 3a, ... minutes after the start time, the second one will be at 0, b, 2b, 3b, ... minutes, and the third one will be on the left side of the pool after 0, c, 2c, 3c, ... minutes.
You came to the left side of the pool exactly p minutes after they started swimming. Determine how long you have to wait before one of the swimmers arrives at the left side of the pool.
Input
The first line of the input contains a single integer t (1 β€ t β€ 1000) β the number of test cases. Next t lines contains test case descriptions, one per line.
Each line contains four integers p, a, b and c (1 β€ p, a, b, c β€ 10^{18}), time in minutes after the start, when you came to the pool and times in minutes it take the swimmers to cross the entire pool and come back.
Output
For each test case, output one integer β how long you have to wait (in minutes) before one of the swimmers arrives at the left side of the pool.
Example
Input
4
9 5 4 8
2 6 10 9
10 2 5 10
10 9 9 9
Output
1
4
0
8
Note
In the first test case, the first swimmer is on the left side in 0, 5, 10, 15, β¦ minutes after the start time, the second swimmer is on the left side in 0, 4, 8, 12, β¦ minutes after the start time, and the third swimmer is on the left side in 0, 8, 16, 24, β¦ minutes after the start time. You arrived at the pool in 9 minutes after the start time and in a minute you will meet the first swimmer on the left side.
In the second test case, the first swimmer is on the left side in 0, 6, 12, 18, β¦ minutes after the start time, the second swimmer is on the left side in 0, 10, 20, 30, β¦ minutes after the start time, and the third swimmer is on the left side in 0, 9, 18, 27, β¦ minutes after the start time. You arrived at the pool 2 minutes after the start time and after 4 minutes meet the first swimmer on the left side.
In the third test case, you came to the pool 10 minutes after the start time. At the same time, all three swimmers are on the left side. A rare stroke of luck!
In the fourth test case, all swimmers are located on the left side in 0, 9, 18, 27, β¦ minutes after the start time. You arrived at the pool 10 minutes after the start time and after 8 minutes meet all three swimmers on the left side.
Submitted Solution:
```
import math
t = int(input())
for i in range(t):
p,a,b,c = [int(i) for i in input().split()]
pa = a*math.ceil(p/a)
pb = b*math.ceil(p/b)
pc = c*math.ceil(p/c)
print((min(min(pa,pb),pc))-p)
``` | instruction | 0 | 28,488 | 17 | 56,976 |
No | output | 1 | 28,488 | 17 | 56,977 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Three swimmers decided to organize a party in the swimming pool! At noon, they started to swim from the left side of the pool.
It takes the first swimmer exactly a minutes to swim across the entire pool and come back, exactly b minutes for the second swimmer and c minutes for the third. Hence, the first swimmer will be on the left side of the pool after 0, a, 2a, 3a, ... minutes after the start time, the second one will be at 0, b, 2b, 3b, ... minutes, and the third one will be on the left side of the pool after 0, c, 2c, 3c, ... minutes.
You came to the left side of the pool exactly p minutes after they started swimming. Determine how long you have to wait before one of the swimmers arrives at the left side of the pool.
Input
The first line of the input contains a single integer t (1 β€ t β€ 1000) β the number of test cases. Next t lines contains test case descriptions, one per line.
Each line contains four integers p, a, b and c (1 β€ p, a, b, c β€ 10^{18}), time in minutes after the start, when you came to the pool and times in minutes it take the swimmers to cross the entire pool and come back.
Output
For each test case, output one integer β how long you have to wait (in minutes) before one of the swimmers arrives at the left side of the pool.
Example
Input
4
9 5 4 8
2 6 10 9
10 2 5 10
10 9 9 9
Output
1
4
0
8
Note
In the first test case, the first swimmer is on the left side in 0, 5, 10, 15, β¦ minutes after the start time, the second swimmer is on the left side in 0, 4, 8, 12, β¦ minutes after the start time, and the third swimmer is on the left side in 0, 8, 16, 24, β¦ minutes after the start time. You arrived at the pool in 9 minutes after the start time and in a minute you will meet the first swimmer on the left side.
In the second test case, the first swimmer is on the left side in 0, 6, 12, 18, β¦ minutes after the start time, the second swimmer is on the left side in 0, 10, 20, 30, β¦ minutes after the start time, and the third swimmer is on the left side in 0, 9, 18, 27, β¦ minutes after the start time. You arrived at the pool 2 minutes after the start time and after 4 minutes meet the first swimmer on the left side.
In the third test case, you came to the pool 10 minutes after the start time. At the same time, all three swimmers are on the left side. A rare stroke of luck!
In the fourth test case, all swimmers are located on the left side in 0, 9, 18, 27, β¦ minutes after the start time. You arrived at the pool 10 minutes after the start time and after 8 minutes meet all three swimmers on the left side.
Submitted Solution:
```
def minutes():
n_test = int(input())
_output = []
for i in range(n_test):
_input = list(map(int, input().split()))
_output.append(minute(_input[0], _input[1], _input[2], _input[3]))
for e in _output:
print(e)
def minute(p, a, b, c):
return min(e-p%e if p%e != 0 else p-e for e in [a, b, c])
if __name__ == "__main__":
minutes()
``` | instruction | 0 | 28,489 | 17 | 56,978 |
No | output | 1 | 28,489 | 17 | 56,979 |
Provide a correct Python 3 solution for this coding contest problem.
problem
Five students, Taro, Jiro, Saburo, Shiro, and Hanako, participated in the JOI High School class.
In this class, a final exam was conducted. All five people took the final exam. For students with a final exam score of 40 or higher, the final exam score was used as is. All students with a final exam score of less than 40 received supplementary lessons and scored 40 points.
Create a program that calculates the average score of the five students' grades given the final exam scores of the five students.
Example
Input
10
65
100
30
95
Output
68 | instruction | 0 | 29,018 | 17 | 58,036 |
"Correct Solution:
```
s=0
y=[]
for i in range(1,6):
x=int(input())
if x>=40:
y.append(x)
else:
y.append(40)
for i in range(0,5):
s+=y[i]
print(int(s/5))
``` | output | 1 | 29,018 | 17 | 58,037 |
Provide a correct Python 3 solution for this coding contest problem.
problem
Five students, Taro, Jiro, Saburo, Shiro, and Hanako, participated in the JOI High School class.
In this class, a final exam was conducted. All five people took the final exam. For students with a final exam score of 40 or higher, the final exam score was used as is. All students with a final exam score of less than 40 received supplementary lessons and scored 40 points.
Create a program that calculates the average score of the five students' grades given the final exam scores of the five students.
Example
Input
10
65
100
30
95
Output
68 | instruction | 0 | 29,019 | 17 | 58,038 |
"Correct Solution:
```
point=[int(input())for i in range(5)]
t=0
for p in point:
if p<40:t+=40
else:t+=p
print(t//5)
``` | output | 1 | 29,019 | 17 | 58,039 |
Provide a correct Python 3 solution for this coding contest problem.
problem
Five students, Taro, Jiro, Saburo, Shiro, and Hanako, participated in the JOI High School class.
In this class, a final exam was conducted. All five people took the final exam. For students with a final exam score of 40 or higher, the final exam score was used as is. All students with a final exam score of less than 40 received supplementary lessons and scored 40 points.
Create a program that calculates the average score of the five students' grades given the final exam scores of the five students.
Example
Input
10
65
100
30
95
Output
68 | instruction | 0 | 29,020 | 17 | 58,040 |
"Correct Solution:
```
seiseki = []
for a in range(5):
seiseki.append(int(input()))
for b in range(5):
if seiseki[b] < 40:
seiseki[b] = 40
print(sum(seiseki)//5)
``` | output | 1 | 29,020 | 17 | 58,041 |
Provide a correct Python 3 solution for this coding contest problem.
problem
Five students, Taro, Jiro, Saburo, Shiro, and Hanako, participated in the JOI High School class.
In this class, a final exam was conducted. All five people took the final exam. For students with a final exam score of 40 or higher, the final exam score was used as is. All students with a final exam score of less than 40 received supplementary lessons and scored 40 points.
Create a program that calculates the average score of the five students' grades given the final exam scores of the five students.
Example
Input
10
65
100
30
95
Output
68 | instruction | 0 | 29,021 | 17 | 58,042 |
"Correct Solution:
```
def is_odd(n):
return(n<40)
a=int(input())
b=int(input())
c=int(input())
d=int(input())
e=int(input())
m=[a, b, c, d, e]
k=filter(is_odd, m)
t=list(k)
f=len(t)
def is_odd(x):
return(x>=40)
s=filter(is_odd, m)
l=list(s)
print((sum(l)+f*40)//5)
``` | output | 1 | 29,021 | 17 | 58,043 |
Provide a correct Python 3 solution for this coding contest problem.
problem
Five students, Taro, Jiro, Saburo, Shiro, and Hanako, participated in the JOI High School class.
In this class, a final exam was conducted. All five people took the final exam. For students with a final exam score of 40 or higher, the final exam score was used as is. All students with a final exam score of less than 40 received supplementary lessons and scored 40 points.
Create a program that calculates the average score of the five students' grades given the final exam scores of the five students.
Example
Input
10
65
100
30
95
Output
68 | instruction | 0 | 29,022 | 17 | 58,044 |
"Correct Solution:
```
x=0
for i in range(5):
n=int(input())
if n<40:
n=40
#print(n)
x+=n
print(
format(x/5,'.0f')
)
``` | output | 1 | 29,022 | 17 | 58,045 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.