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 |
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A multi-subject competition is coming! The competition has m different subjects participants can choose from. That's why Alex (the coach) should form a competition delegation among his students.
He has n candidates. For the i-th person he knows subject s_i the candidate specializes in and r_i — a skill level in his specialization (this level can be negative!).
The rules of the competition require each delegation to choose some subset of subjects they will participate in. The only restriction is that the number of students from the team participating in each of the chosen subjects should be the same.
Alex decided that each candidate would participate only in the subject he specializes in. Now Alex wonders whom he has to choose to maximize the total sum of skill levels of all delegates, or just skip the competition this year if every valid non-empty delegation has negative sum.
(Of course, Alex doesn't have any spare money so each delegate he chooses must participate in the competition).
Input
The first line contains two integers n and m (1 ≤ n ≤ 10^5, 1 ≤ m ≤ 10^5) — the number of candidates and the number of subjects.
The next n lines contains two integers per line: s_i and r_i (1 ≤ s_i ≤ m, -10^4 ≤ r_i ≤ 10^4) — the subject of specialization and the skill level of the i-th candidate.
Output
Print the single integer — the maximum total sum of skills of delegates who form a valid delegation (according to rules above) or 0 if every valid non-empty delegation has negative sum.
Examples
Input
6 3
2 6
3 6
2 5
3 5
1 9
3 1
Output
22
Input
5 3
2 6
3 6
2 5
3 5
1 11
Output
23
Input
5 2
1 -1
1 -5
2 -1
2 -1
1 -10
Output
0
Note
In the first example it's optimal to choose candidates 1, 2, 3, 4, so two of them specialize in the 2-nd subject and other two in the 3-rd. The total sum is 6 + 6 + 5 + 5 = 22.
In the second example it's optimal to choose candidates 1, 2 and 5. One person in each subject and the total sum is 6 + 6 + 11 = 23.
In the third example it's impossible to obtain a non-negative sum.
Submitted Solution:
```
from collections import defaultdict
n,m = map(int,input().split())
D = defaultdict(list)
for i in range(n):
a,b = map(int,input().split())
D[a].append(b)
MAX = 0
for i in range(1,m+1):
if(D[i]):
D[i].sort(reverse = True)
for j in range(1,len(D[i])):
D[i][j] += D[i][j-1]
MAX = max(MAX, len(D[i]))
ans =0
for i in range(1,MAX + 1):
temp = 0
for j in range(1,m+1):
if(len(D[j])>= i):
temp += D[j][i-1]
ans = max(temp, ans)
print(ans)
``` | instruction | 0 | 20,317 | 17 | 40,634 |
No | output | 1 | 20,317 | 17 | 40,635 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Translator's note: in Russia's most widespread grading system, there are four grades: 5, 4, 3, 2, the higher the better, roughly corresponding to A, B, C and F respectively in American grading system.
The term is coming to an end and students start thinking about their grades. Today, a professor told his students that the grades for his course would be given out automatically — he would calculate the simple average (arithmetic mean) of all grades given out for lab works this term and round to the nearest integer. The rounding would be done in favour of the student — 4.5 would be rounded up to 5 (as in example 3), but 4.4 would be rounded down to 4.
This does not bode well for Vasya who didn't think those lab works would influence anything, so he may receive a grade worse than 5 (maybe even the dreaded 2). However, the professor allowed him to redo some of his works of Vasya's choosing to increase his average grade. Vasya wants to redo as as few lab works as possible in order to get 5 for the course. Of course, Vasya will get 5 for the lab works he chooses to redo.
Help Vasya — calculate the minimum amount of lab works Vasya has to redo.
Input
The first line contains a single integer n — the number of Vasya's grades (1 ≤ n ≤ 100).
The second line contains n integers from 2 to 5 — Vasya's grades for his lab works.
Output
Output a single integer — the minimum amount of lab works that Vasya has to redo. It can be shown that Vasya can always redo enough lab works to get a 5.
Examples
Input
3
4 4 4
Output
2
Input
4
5 4 5 5
Output
0
Input
4
5 3 3 5
Output
1
Note
In the first sample, it is enough to redo two lab works to make two 4s into 5s.
In the second sample, Vasya's average is already 4.75 so he doesn't have to redo anything to get a 5.
In the second sample Vasya has to redo one lab work to get rid of one of the 3s, that will make the average exactly 4.5 so the final grade would be 5. | instruction | 0 | 20,914 | 17 | 41,828 |
Tags: greedy, sortings
Correct Solution:
```
from statistics import mean
n = int(input())
m = list(map(int, input().split()))
def roundTraditional(val,digits):
return round(val+10**(-len(str(val))-1), digits)
m.sort()
i = 0
while roundTraditional(mean(m), 0) < 5:
m[i] = 5
i += 1
print(i)
``` | output | 1 | 20,914 | 17 | 41,829 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Translator's note: in Russia's most widespread grading system, there are four grades: 5, 4, 3, 2, the higher the better, roughly corresponding to A, B, C and F respectively in American grading system.
The term is coming to an end and students start thinking about their grades. Today, a professor told his students that the grades for his course would be given out automatically — he would calculate the simple average (arithmetic mean) of all grades given out for lab works this term and round to the nearest integer. The rounding would be done in favour of the student — 4.5 would be rounded up to 5 (as in example 3), but 4.4 would be rounded down to 4.
This does not bode well for Vasya who didn't think those lab works would influence anything, so he may receive a grade worse than 5 (maybe even the dreaded 2). However, the professor allowed him to redo some of his works of Vasya's choosing to increase his average grade. Vasya wants to redo as as few lab works as possible in order to get 5 for the course. Of course, Vasya will get 5 for the lab works he chooses to redo.
Help Vasya — calculate the minimum amount of lab works Vasya has to redo.
Input
The first line contains a single integer n — the number of Vasya's grades (1 ≤ n ≤ 100).
The second line contains n integers from 2 to 5 — Vasya's grades for his lab works.
Output
Output a single integer — the minimum amount of lab works that Vasya has to redo. It can be shown that Vasya can always redo enough lab works to get a 5.
Examples
Input
3
4 4 4
Output
2
Input
4
5 4 5 5
Output
0
Input
4
5 3 3 5
Output
1
Note
In the first sample, it is enough to redo two lab works to make two 4s into 5s.
In the second sample, Vasya's average is already 4.75 so he doesn't have to redo anything to get a 5.
In the second sample Vasya has to redo one lab work to get rid of one of the 3s, that will make the average exactly 4.5 so the final grade would be 5. | instruction | 0 | 20,915 | 17 | 41,830 |
Tags: greedy, sortings
Correct Solution:
```
n = int(input())
grades = [int(x) * 2 for x in input().split()]
res = sum(grades)
target = 9 * len(grades)
grades.sort()
for i, grade in enumerate(grades):
if res >= target:
print(i)
break
else:
res += 10 - grade
else:
print(len(grades))
``` | output | 1 | 20,915 | 17 | 41,831 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Translator's note: in Russia's most widespread grading system, there are four grades: 5, 4, 3, 2, the higher the better, roughly corresponding to A, B, C and F respectively in American grading system.
The term is coming to an end and students start thinking about their grades. Today, a professor told his students that the grades for his course would be given out automatically — he would calculate the simple average (arithmetic mean) of all grades given out for lab works this term and round to the nearest integer. The rounding would be done in favour of the student — 4.5 would be rounded up to 5 (as in example 3), but 4.4 would be rounded down to 4.
This does not bode well for Vasya who didn't think those lab works would influence anything, so he may receive a grade worse than 5 (maybe even the dreaded 2). However, the professor allowed him to redo some of his works of Vasya's choosing to increase his average grade. Vasya wants to redo as as few lab works as possible in order to get 5 for the course. Of course, Vasya will get 5 for the lab works he chooses to redo.
Help Vasya — calculate the minimum amount of lab works Vasya has to redo.
Input
The first line contains a single integer n — the number of Vasya's grades (1 ≤ n ≤ 100).
The second line contains n integers from 2 to 5 — Vasya's grades for his lab works.
Output
Output a single integer — the minimum amount of lab works that Vasya has to redo. It can be shown that Vasya can always redo enough lab works to get a 5.
Examples
Input
3
4 4 4
Output
2
Input
4
5 4 5 5
Output
0
Input
4
5 3 3 5
Output
1
Note
In the first sample, it is enough to redo two lab works to make two 4s into 5s.
In the second sample, Vasya's average is already 4.75 so he doesn't have to redo anything to get a 5.
In the second sample Vasya has to redo one lab work to get rid of one of the 3s, that will make the average exactly 4.5 so the final grade would be 5. | instruction | 0 | 20,916 | 17 | 41,832 |
Tags: greedy, sortings
Correct Solution:
```
import sys
import math
import itertools
import collections
def ii(): return int(input())
def mi(): return map(int, input().split())
def li(): return list(map(int, input().split()))
def lcm(a, b): return abs(a * b) // math.gcd(a, b)
def wr(arr): return ' '.join(map(str, arr))
def revn(n): return str(n)[::-1]
def dd(): return collections.defaultdict(int)
def ddl(): return collections.defaultdict(list)
def sieve(n):
if n < 2: return list()
prime = [True for _ in range(n + 1)]
p = 3
while p * p <= n:
if prime[p]:
for i in range(p * 2, n + 1, p):
prime[i] = False
p += 2
r = [2]
for p in range(3, n + 1, 2):
if prime[p]:
r.append(p)
return r
def divs(n, start=1):
r = []
for i in range(start, int(math.sqrt(n) + 1)):
if (n % i == 0):
if (n / i == i):
r.append(i)
else:
r.extend([i, n // i])
return r
def divn(n, primes):
divs_number = 1
for i in primes:
if n == 1:
return divs_number
t = 1
while n % i == 0:
t += 1
n //= i
divs_number *= t
def prime(n):
if n == 2: return True
if n % 2 == 0 or n <= 1: return False
sqr = int(math.sqrt(n)) + 1
for d in range(3, sqr, 2):
if n % d == 0: return False
return True
def convn(number, base):
newnumber = 0
while number > 0:
newnumber += number % base
number //= base
return newnumber
def cdiv(n, k): return n // k + (n % k != 0)
n = ii()
a = sorted(li())
i = 0
while sum(a) * 2 < 9 * n:
if a[i] == 5:
continue
else:
a[i] = 5
i += 1
print(i)
``` | output | 1 | 20,916 | 17 | 41,833 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Translator's note: in Russia's most widespread grading system, there are four grades: 5, 4, 3, 2, the higher the better, roughly corresponding to A, B, C and F respectively in American grading system.
The term is coming to an end and students start thinking about their grades. Today, a professor told his students that the grades for his course would be given out automatically — he would calculate the simple average (arithmetic mean) of all grades given out for lab works this term and round to the nearest integer. The rounding would be done in favour of the student — 4.5 would be rounded up to 5 (as in example 3), but 4.4 would be rounded down to 4.
This does not bode well for Vasya who didn't think those lab works would influence anything, so he may receive a grade worse than 5 (maybe even the dreaded 2). However, the professor allowed him to redo some of his works of Vasya's choosing to increase his average grade. Vasya wants to redo as as few lab works as possible in order to get 5 for the course. Of course, Vasya will get 5 for the lab works he chooses to redo.
Help Vasya — calculate the minimum amount of lab works Vasya has to redo.
Input
The first line contains a single integer n — the number of Vasya's grades (1 ≤ n ≤ 100).
The second line contains n integers from 2 to 5 — Vasya's grades for his lab works.
Output
Output a single integer — the minimum amount of lab works that Vasya has to redo. It can be shown that Vasya can always redo enough lab works to get a 5.
Examples
Input
3
4 4 4
Output
2
Input
4
5 4 5 5
Output
0
Input
4
5 3 3 5
Output
1
Note
In the first sample, it is enough to redo two lab works to make two 4s into 5s.
In the second sample, Vasya's average is already 4.75 so he doesn't have to redo anything to get a 5.
In the second sample Vasya has to redo one lab work to get rid of one of the 3s, that will make the average exactly 4.5 so the final grade would be 5. | instruction | 0 | 20,917 | 17 | 41,834 |
Tags: greedy, sortings
Correct Solution:
```
def result(a):
b = sorted(a)
summa = sum(a)
m = len(a)
count = 0
while not summa * 10 >= m * 45:
summa += 5 - b[count]
count += 1
return count
lt = int(input())
lst = [int(i) for i in input().split()]
print(result(lst))
``` | output | 1 | 20,917 | 17 | 41,835 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Translator's note: in Russia's most widespread grading system, there are four grades: 5, 4, 3, 2, the higher the better, roughly corresponding to A, B, C and F respectively in American grading system.
The term is coming to an end and students start thinking about their grades. Today, a professor told his students that the grades for his course would be given out automatically — he would calculate the simple average (arithmetic mean) of all grades given out for lab works this term and round to the nearest integer. The rounding would be done in favour of the student — 4.5 would be rounded up to 5 (as in example 3), but 4.4 would be rounded down to 4.
This does not bode well for Vasya who didn't think those lab works would influence anything, so he may receive a grade worse than 5 (maybe even the dreaded 2). However, the professor allowed him to redo some of his works of Vasya's choosing to increase his average grade. Vasya wants to redo as as few lab works as possible in order to get 5 for the course. Of course, Vasya will get 5 for the lab works he chooses to redo.
Help Vasya — calculate the minimum amount of lab works Vasya has to redo.
Input
The first line contains a single integer n — the number of Vasya's grades (1 ≤ n ≤ 100).
The second line contains n integers from 2 to 5 — Vasya's grades for his lab works.
Output
Output a single integer — the minimum amount of lab works that Vasya has to redo. It can be shown that Vasya can always redo enough lab works to get a 5.
Examples
Input
3
4 4 4
Output
2
Input
4
5 4 5 5
Output
0
Input
4
5 3 3 5
Output
1
Note
In the first sample, it is enough to redo two lab works to make two 4s into 5s.
In the second sample, Vasya's average is already 4.75 so he doesn't have to redo anything to get a 5.
In the second sample Vasya has to redo one lab work to get rid of one of the 3s, that will make the average exactly 4.5 so the final grade would be 5. | instruction | 0 | 20,918 | 17 | 41,836 |
Tags: greedy, sortings
Correct Solution:
```
n=int(input())
li=[int(x) for x in input().split()]
av=sum(li)/n
if av>=4.5:
print(0)
exit()
else:
two=li.count(2)
three=li.count(3)
four=li.count(4)
five=li.count(5)
ccc=0
while True:
if two!=0:
two-=1
five+=1
ccc+=1
elif three !=0:
three-=1
five+=1
ccc+=1
else:
four-=1
five+=1
ccc+=1
if (two*2+three*3+four*4+five*5)/n>=4.5:
print(ccc)
quit()
``` | output | 1 | 20,918 | 17 | 41,837 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Translator's note: in Russia's most widespread grading system, there are four grades: 5, 4, 3, 2, the higher the better, roughly corresponding to A, B, C and F respectively in American grading system.
The term is coming to an end and students start thinking about their grades. Today, a professor told his students that the grades for his course would be given out automatically — he would calculate the simple average (arithmetic mean) of all grades given out for lab works this term and round to the nearest integer. The rounding would be done in favour of the student — 4.5 would be rounded up to 5 (as in example 3), but 4.4 would be rounded down to 4.
This does not bode well for Vasya who didn't think those lab works would influence anything, so he may receive a grade worse than 5 (maybe even the dreaded 2). However, the professor allowed him to redo some of his works of Vasya's choosing to increase his average grade. Vasya wants to redo as as few lab works as possible in order to get 5 for the course. Of course, Vasya will get 5 for the lab works he chooses to redo.
Help Vasya — calculate the minimum amount of lab works Vasya has to redo.
Input
The first line contains a single integer n — the number of Vasya's grades (1 ≤ n ≤ 100).
The second line contains n integers from 2 to 5 — Vasya's grades for his lab works.
Output
Output a single integer — the minimum amount of lab works that Vasya has to redo. It can be shown that Vasya can always redo enough lab works to get a 5.
Examples
Input
3
4 4 4
Output
2
Input
4
5 4 5 5
Output
0
Input
4
5 3 3 5
Output
1
Note
In the first sample, it is enough to redo two lab works to make two 4s into 5s.
In the second sample, Vasya's average is already 4.75 so he doesn't have to redo anything to get a 5.
In the second sample Vasya has to redo one lab work to get rid of one of the 3s, that will make the average exactly 4.5 so the final grade would be 5. | instruction | 0 | 20,919 | 17 | 41,838 |
Tags: greedy, sortings
Correct Solution:
```
import math
def my_rounder(fl):
fl_str = str(fl)
index = fl_str.find(".")
decimal = fl_str[index + 1:]
int_decimal = int(decimal)
int_part = int(fl_str[:index])
thousand = int("1" + "0" * len(decimal))
if thousand - int_decimal > int_decimal:
return int_part
return int_part + 1
def main_function():
input()
grades = sorted([int(i) for i in input().split(" ")])
count = 0
while not my_rounder(sum(grades) / len(grades)) == 5:
grades[count] = 5
count += 1
return count
print(main_function())
``` | output | 1 | 20,919 | 17 | 41,839 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Translator's note: in Russia's most widespread grading system, there are four grades: 5, 4, 3, 2, the higher the better, roughly corresponding to A, B, C and F respectively in American grading system.
The term is coming to an end and students start thinking about their grades. Today, a professor told his students that the grades for his course would be given out automatically — he would calculate the simple average (arithmetic mean) of all grades given out for lab works this term and round to the nearest integer. The rounding would be done in favour of the student — 4.5 would be rounded up to 5 (as in example 3), but 4.4 would be rounded down to 4.
This does not bode well for Vasya who didn't think those lab works would influence anything, so he may receive a grade worse than 5 (maybe even the dreaded 2). However, the professor allowed him to redo some of his works of Vasya's choosing to increase his average grade. Vasya wants to redo as as few lab works as possible in order to get 5 for the course. Of course, Vasya will get 5 for the lab works he chooses to redo.
Help Vasya — calculate the minimum amount of lab works Vasya has to redo.
Input
The first line contains a single integer n — the number of Vasya's grades (1 ≤ n ≤ 100).
The second line contains n integers from 2 to 5 — Vasya's grades for his lab works.
Output
Output a single integer — the minimum amount of lab works that Vasya has to redo. It can be shown that Vasya can always redo enough lab works to get a 5.
Examples
Input
3
4 4 4
Output
2
Input
4
5 4 5 5
Output
0
Input
4
5 3 3 5
Output
1
Note
In the first sample, it is enough to redo two lab works to make two 4s into 5s.
In the second sample, Vasya's average is already 4.75 so he doesn't have to redo anything to get a 5.
In the second sample Vasya has to redo one lab work to get rid of one of the 3s, that will make the average exactly 4.5 so the final grade would be 5. | instruction | 0 | 20,920 | 17 | 41,840 |
Tags: greedy, sortings
Correct Solution:
```
n = int(input())
list =list(map(int, input().split()))
# print(list)
mean = 1
# sum = 0
# count = 0
# listcopy =[]
# for i in range(len(list)):
# sum = sum + list[i]
# listcopy.append(list[i])
# mean = sum/len(list)
list.sort()
# print(sum)
# print(mean)
# listcopy.sort()
# print(listcopy)
# if mean > 4.5:
# print("0")
# sum1 = 0
# mean2 = 1
# for i in range(len(list)):
# list[i] = 5
# count+=1
# sum+=list[i]
# mean2 = mean2/len(list)
# if mean2 > 4.5:
# break
# print(count)
sum = 0
for i in range(len(list)):
sum+=list[i]
count = 0
mean = sum/len(list)
for i in range(len(list)):
if mean>= 4.5:
break
else:
sum +=(5-list[i])
list[i]=5
mean = sum/len(list)
count+=1
print(count)
``` | output | 1 | 20,920 | 17 | 41,841 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Translator's note: in Russia's most widespread grading system, there are four grades: 5, 4, 3, 2, the higher the better, roughly corresponding to A, B, C and F respectively in American grading system.
The term is coming to an end and students start thinking about their grades. Today, a professor told his students that the grades for his course would be given out automatically — he would calculate the simple average (arithmetic mean) of all grades given out for lab works this term and round to the nearest integer. The rounding would be done in favour of the student — 4.5 would be rounded up to 5 (as in example 3), but 4.4 would be rounded down to 4.
This does not bode well for Vasya who didn't think those lab works would influence anything, so he may receive a grade worse than 5 (maybe even the dreaded 2). However, the professor allowed him to redo some of his works of Vasya's choosing to increase his average grade. Vasya wants to redo as as few lab works as possible in order to get 5 for the course. Of course, Vasya will get 5 for the lab works he chooses to redo.
Help Vasya — calculate the minimum amount of lab works Vasya has to redo.
Input
The first line contains a single integer n — the number of Vasya's grades (1 ≤ n ≤ 100).
The second line contains n integers from 2 to 5 — Vasya's grades for his lab works.
Output
Output a single integer — the minimum amount of lab works that Vasya has to redo. It can be shown that Vasya can always redo enough lab works to get a 5.
Examples
Input
3
4 4 4
Output
2
Input
4
5 4 5 5
Output
0
Input
4
5 3 3 5
Output
1
Note
In the first sample, it is enough to redo two lab works to make two 4s into 5s.
In the second sample, Vasya's average is already 4.75 so he doesn't have to redo anything to get a 5.
In the second sample Vasya has to redo one lab work to get rid of one of the 3s, that will make the average exactly 4.5 so the final grade would be 5. | instruction | 0 | 20,921 | 17 | 41,842 |
Tags: greedy, sortings
Correct Solution:
```
# R = lambda: map(int, input().split())
R = lambda: map(lambda x: int(x)*2, input().split())
n = int(input())
arr = list(R())
arr.sort()
ans = 0
s = sum(arr)
while s < 9*n:
s += 10 - arr[ans]
ans += 1
print(ans)
``` | output | 1 | 20,921 | 17 | 41,843 |
Provide a correct Python 3 solution for this coding contest problem.
problem
JOI decided to play a game with his friends. N players participate in this game. The rules for a single game are as follows:
Each player writes a favorite integer from 1 to 100 on the card and submits it. Each player gets the same score as he wrote if no one else wrote the same number. If there is another person who wrote the same number as you, you will not get a score.
JOI You guys played this game 3 times. Create a program to find the total score each player has earned in the three games given the number each player has written in the three games.
input
The input consists of 1 + N lines.
The integer N (2 ≤ N ≤ 200) is written on the first line, which indicates the number of players.
In the i-th line (1 ≤ i ≤ N) of the following N lines, three integers from 1 to 100 are written separated by blanks, and the i-th player is the first, second, and third times, respectively. Represents the number written in the game of.
output
The output consists of N lines.
On line i (1 ≤ i ≤ N), output an integer representing the total score obtained by the i-th player in the three games.
Input / output example
Input example 1
Five
100 99 98
100 97 92
63 89 63
99 99 99
89 97 98
Output example 1
0
92
215
198
89
In example 1, the details of the points scored by each player in the three games are as follows:
Player 1: 0 + 0 + 0 = 0
---
Player 2: 0 + 0 + 92 = 92
Player 3: 63 + 89 + 63 = 215
Player 4: 99 + 0 + 99 = 198
Player 5: 89 + 0 + 0 = 89
Input example 2
3
89 92 77
89 92 63
89 63 77
Output example 2
0
63
63
The question text and the data used for the automatic referee are the question text and the test data for scoring that are created and published by the Japan Committee for Information Olympics.
Example
Input
5
100 99 98
100 97 92
63 89 63
99 99 99
89 97 98
Output
0
92
215
198
89 | instruction | 0 | 21,082 | 17 | 42,164 |
"Correct Solution:
```
N = int(input())
score = [input().split() for _ in range(N)]
players = [0]*N
for play in list(zip(*score)):
for i, p in enumerate(play):
if play.count(p) == 1:
players[i] += int(p)
print(*players, sep='\n')
``` | output | 1 | 21,082 | 17 | 42,165 |
Provide a correct Python 3 solution for this coding contest problem.
problem
JOI decided to play a game with his friends. N players participate in this game. The rules for a single game are as follows:
Each player writes a favorite integer from 1 to 100 on the card and submits it. Each player gets the same score as he wrote if no one else wrote the same number. If there is another person who wrote the same number as you, you will not get a score.
JOI You guys played this game 3 times. Create a program to find the total score each player has earned in the three games given the number each player has written in the three games.
input
The input consists of 1 + N lines.
The integer N (2 ≤ N ≤ 200) is written on the first line, which indicates the number of players.
In the i-th line (1 ≤ i ≤ N) of the following N lines, three integers from 1 to 100 are written separated by blanks, and the i-th player is the first, second, and third times, respectively. Represents the number written in the game of.
output
The output consists of N lines.
On line i (1 ≤ i ≤ N), output an integer representing the total score obtained by the i-th player in the three games.
Input / output example
Input example 1
Five
100 99 98
100 97 92
63 89 63
99 99 99
89 97 98
Output example 1
0
92
215
198
89
In example 1, the details of the points scored by each player in the three games are as follows:
Player 1: 0 + 0 + 0 = 0
---
Player 2: 0 + 0 + 92 = 92
Player 3: 63 + 89 + 63 = 215
Player 4: 99 + 0 + 99 = 198
Player 5: 89 + 0 + 0 = 89
Input example 2
3
89 92 77
89 92 63
89 63 77
Output example 2
0
63
63
The question text and the data used for the automatic referee are the question text and the test data for scoring that are created and published by the Japan Committee for Information Olympics.
Example
Input
5
100 99 98
100 97 92
63 89 63
99 99 99
89 97 98
Output
0
92
215
198
89 | instruction | 0 | 21,083 | 17 | 42,166 |
"Correct Solution:
```
N = int(input())
score = [list(map(int, input().split())) for _ in range(N)]
players = [0 for _ in range(N)]
for play in list(zip(*score)):
for i, p in enumerate(play):
if play.count(p) == 1:
players[i] += p
print(*players, sep='\n')
``` | output | 1 | 21,083 | 17 | 42,167 |
Provide a correct Python 3 solution for this coding contest problem.
problem
JOI decided to play a game with his friends. N players participate in this game. The rules for a single game are as follows:
Each player writes a favorite integer from 1 to 100 on the card and submits it. Each player gets the same score as he wrote if no one else wrote the same number. If there is another person who wrote the same number as you, you will not get a score.
JOI You guys played this game 3 times. Create a program to find the total score each player has earned in the three games given the number each player has written in the three games.
input
The input consists of 1 + N lines.
The integer N (2 ≤ N ≤ 200) is written on the first line, which indicates the number of players.
In the i-th line (1 ≤ i ≤ N) of the following N lines, three integers from 1 to 100 are written separated by blanks, and the i-th player is the first, second, and third times, respectively. Represents the number written in the game of.
output
The output consists of N lines.
On line i (1 ≤ i ≤ N), output an integer representing the total score obtained by the i-th player in the three games.
Input / output example
Input example 1
Five
100 99 98
100 97 92
63 89 63
99 99 99
89 97 98
Output example 1
0
92
215
198
89
In example 1, the details of the points scored by each player in the three games are as follows:
Player 1: 0 + 0 + 0 = 0
---
Player 2: 0 + 0 + 92 = 92
Player 3: 63 + 89 + 63 = 215
Player 4: 99 + 0 + 99 = 198
Player 5: 89 + 0 + 0 = 89
Input example 2
3
89 92 77
89 92 63
89 63 77
Output example 2
0
63
63
The question text and the data used for the automatic referee are the question text and the test data for scoring that are created and published by the Japan Committee for Information Olympics.
Example
Input
5
100 99 98
100 97 92
63 89 63
99 99 99
89 97 98
Output
0
92
215
198
89 | instruction | 0 | 21,084 | 17 | 42,168 |
"Correct Solution:
```
n = int(input())
l = [list(map(int,input().split())) for i in range(n)]
A = [l[i][0] for i in range(n)]
B = [l[i][1] for i in range(n)]
C = [l[i][2] for i in range(n)]
p = [0 for i in range(n)]
for i in range(n):
if A.count(l[i][0]) < 2:
p[i] += l[i][0]
if B.count(l[i][1]) < 2:
p[i] += l[i][1]
if C.count(l[i][2]) < 2:
p[i] += l[i][2]
print(p[i])
``` | output | 1 | 21,084 | 17 | 42,169 |
Provide a correct Python 3 solution for this coding contest problem.
problem
JOI decided to play a game with his friends. N players participate in this game. The rules for a single game are as follows:
Each player writes a favorite integer from 1 to 100 on the card and submits it. Each player gets the same score as he wrote if no one else wrote the same number. If there is another person who wrote the same number as you, you will not get a score.
JOI You guys played this game 3 times. Create a program to find the total score each player has earned in the three games given the number each player has written in the three games.
input
The input consists of 1 + N lines.
The integer N (2 ≤ N ≤ 200) is written on the first line, which indicates the number of players.
In the i-th line (1 ≤ i ≤ N) of the following N lines, three integers from 1 to 100 are written separated by blanks, and the i-th player is the first, second, and third times, respectively. Represents the number written in the game of.
output
The output consists of N lines.
On line i (1 ≤ i ≤ N), output an integer representing the total score obtained by the i-th player in the three games.
Input / output example
Input example 1
Five
100 99 98
100 97 92
63 89 63
99 99 99
89 97 98
Output example 1
0
92
215
198
89
In example 1, the details of the points scored by each player in the three games are as follows:
Player 1: 0 + 0 + 0 = 0
---
Player 2: 0 + 0 + 92 = 92
Player 3: 63 + 89 + 63 = 215
Player 4: 99 + 0 + 99 = 198
Player 5: 89 + 0 + 0 = 89
Input example 2
3
89 92 77
89 92 63
89 63 77
Output example 2
0
63
63
The question text and the data used for the automatic referee are the question text and the test data for scoring that are created and published by the Japan Committee for Information Olympics.
Example
Input
5
100 99 98
100 97 92
63 89 63
99 99 99
89 97 98
Output
0
92
215
198
89 | instruction | 0 | 21,085 | 17 | 42,170 |
"Correct Solution:
```
n = int(input())
a = []
b = []
c = []
for i in range(n):
x,y,z = map(int, input().split())
a.append(x)
b.append(y)
c.append(z)
for i in range(n):
score = 0
if a.count(a[i]) == 1:
score += a[i]
if b.count(b[i]) == 1:
score += b[i]
if c.count(c[i]) == 1:
score += c[i]
print(score)
``` | output | 1 | 21,085 | 17 | 42,171 |
Provide a correct Python 3 solution for this coding contest problem.
problem
JOI decided to play a game with his friends. N players participate in this game. The rules for a single game are as follows:
Each player writes a favorite integer from 1 to 100 on the card and submits it. Each player gets the same score as he wrote if no one else wrote the same number. If there is another person who wrote the same number as you, you will not get a score.
JOI You guys played this game 3 times. Create a program to find the total score each player has earned in the three games given the number each player has written in the three games.
input
The input consists of 1 + N lines.
The integer N (2 ≤ N ≤ 200) is written on the first line, which indicates the number of players.
In the i-th line (1 ≤ i ≤ N) of the following N lines, three integers from 1 to 100 are written separated by blanks, and the i-th player is the first, second, and third times, respectively. Represents the number written in the game of.
output
The output consists of N lines.
On line i (1 ≤ i ≤ N), output an integer representing the total score obtained by the i-th player in the three games.
Input / output example
Input example 1
Five
100 99 98
100 97 92
63 89 63
99 99 99
89 97 98
Output example 1
0
92
215
198
89
In example 1, the details of the points scored by each player in the three games are as follows:
Player 1: 0 + 0 + 0 = 0
---
Player 2: 0 + 0 + 92 = 92
Player 3: 63 + 89 + 63 = 215
Player 4: 99 + 0 + 99 = 198
Player 5: 89 + 0 + 0 = 89
Input example 2
3
89 92 77
89 92 63
89 63 77
Output example 2
0
63
63
The question text and the data used for the automatic referee are the question text and the test data for scoring that are created and published by the Japan Committee for Information Olympics.
Example
Input
5
100 99 98
100 97 92
63 89 63
99 99 99
89 97 98
Output
0
92
215
198
89 | instruction | 0 | 21,086 | 17 | 42,172 |
"Correct Solution:
```
num = int(input())
P =[]
L = [[],[],[]]
for _ in range(num):
p = [int(x) for x in input().split()]
P.append(p)
for i in range(3):
L[i].append(p[i])
for p in P:
sum = 0
for i in range(3):
if L[i].count(p[i]) < 2:
sum += p[i]
print(sum)
``` | output | 1 | 21,086 | 17 | 42,173 |
Provide a correct Python 3 solution for this coding contest problem.
problem
JOI decided to play a game with his friends. N players participate in this game. The rules for a single game are as follows:
Each player writes a favorite integer from 1 to 100 on the card and submits it. Each player gets the same score as he wrote if no one else wrote the same number. If there is another person who wrote the same number as you, you will not get a score.
JOI You guys played this game 3 times. Create a program to find the total score each player has earned in the three games given the number each player has written in the three games.
input
The input consists of 1 + N lines.
The integer N (2 ≤ N ≤ 200) is written on the first line, which indicates the number of players.
In the i-th line (1 ≤ i ≤ N) of the following N lines, three integers from 1 to 100 are written separated by blanks, and the i-th player is the first, second, and third times, respectively. Represents the number written in the game of.
output
The output consists of N lines.
On line i (1 ≤ i ≤ N), output an integer representing the total score obtained by the i-th player in the three games.
Input / output example
Input example 1
Five
100 99 98
100 97 92
63 89 63
99 99 99
89 97 98
Output example 1
0
92
215
198
89
In example 1, the details of the points scored by each player in the three games are as follows:
Player 1: 0 + 0 + 0 = 0
---
Player 2: 0 + 0 + 92 = 92
Player 3: 63 + 89 + 63 = 215
Player 4: 99 + 0 + 99 = 198
Player 5: 89 + 0 + 0 = 89
Input example 2
3
89 92 77
89 92 63
89 63 77
Output example 2
0
63
63
The question text and the data used for the automatic referee are the question text and the test data for scoring that are created and published by the Japan Committee for Information Olympics.
Example
Input
5
100 99 98
100 97 92
63 89 63
99 99 99
89 97 98
Output
0
92
215
198
89 | instruction | 0 | 21,087 | 17 | 42,174 |
"Correct Solution:
```
N = int(input())
all_game = [[int(j) for j in input().split()] for i in range(N)]
point = [0] * N
for g_i in range(3):
g = [int(no[g_i]) for no in all_game]
dic = {}
for x in g:
if x not in dic:
dic[x] = 1
else:
dic[x] += 1
for p_i in range(N):
if dic[g[p_i]] == 1:
point[p_i] += g[p_i]
for line in point:
print(line)
``` | output | 1 | 21,087 | 17 | 42,175 |
Provide a correct Python 3 solution for this coding contest problem.
problem
JOI decided to play a game with his friends. N players participate in this game. The rules for a single game are as follows:
Each player writes a favorite integer from 1 to 100 on the card and submits it. Each player gets the same score as he wrote if no one else wrote the same number. If there is another person who wrote the same number as you, you will not get a score.
JOI You guys played this game 3 times. Create a program to find the total score each player has earned in the three games given the number each player has written in the three games.
input
The input consists of 1 + N lines.
The integer N (2 ≤ N ≤ 200) is written on the first line, which indicates the number of players.
In the i-th line (1 ≤ i ≤ N) of the following N lines, three integers from 1 to 100 are written separated by blanks, and the i-th player is the first, second, and third times, respectively. Represents the number written in the game of.
output
The output consists of N lines.
On line i (1 ≤ i ≤ N), output an integer representing the total score obtained by the i-th player in the three games.
Input / output example
Input example 1
Five
100 99 98
100 97 92
63 89 63
99 99 99
89 97 98
Output example 1
0
92
215
198
89
In example 1, the details of the points scored by each player in the three games are as follows:
Player 1: 0 + 0 + 0 = 0
---
Player 2: 0 + 0 + 92 = 92
Player 3: 63 + 89 + 63 = 215
Player 4: 99 + 0 + 99 = 198
Player 5: 89 + 0 + 0 = 89
Input example 2
3
89 92 77
89 92 63
89 63 77
Output example 2
0
63
63
The question text and the data used for the automatic referee are the question text and the test data for scoring that are created and published by the Japan Committee for Information Olympics.
Example
Input
5
100 99 98
100 97 92
63 89 63
99 99 99
89 97 98
Output
0
92
215
198
89 | instruction | 0 | 21,088 | 17 | 42,176 |
"Correct Solution:
```
def main():
N = int(input())
a = []
for _ in range(N):
a.append(list(map(int, input().split())))
n = []
c1 = 0
for _ in range(3):
hoge = []
for x in range(N):
hoge.append(a[x][c1])
c1 += 1
n.append(hoge)
b = [0] * N
for x in range(3):
for y in range(N):
c2 = 0
for z in range(N):
if n[x][y] == n[x][z]:
c2 += 1
else:
pass
if c2 == 1:
b[y] += n[x][y]
for x in range(N):
print(b[x])
if __name__ == "__main__":
main()
``` | output | 1 | 21,088 | 17 | 42,177 |
Provide a correct Python 3 solution for this coding contest problem.
problem
JOI decided to play a game with his friends. N players participate in this game. The rules for a single game are as follows:
Each player writes a favorite integer from 1 to 100 on the card and submits it. Each player gets the same score as he wrote if no one else wrote the same number. If there is another person who wrote the same number as you, you will not get a score.
JOI You guys played this game 3 times. Create a program to find the total score each player has earned in the three games given the number each player has written in the three games.
input
The input consists of 1 + N lines.
The integer N (2 ≤ N ≤ 200) is written on the first line, which indicates the number of players.
In the i-th line (1 ≤ i ≤ N) of the following N lines, three integers from 1 to 100 are written separated by blanks, and the i-th player is the first, second, and third times, respectively. Represents the number written in the game of.
output
The output consists of N lines.
On line i (1 ≤ i ≤ N), output an integer representing the total score obtained by the i-th player in the three games.
Input / output example
Input example 1
Five
100 99 98
100 97 92
63 89 63
99 99 99
89 97 98
Output example 1
0
92
215
198
89
In example 1, the details of the points scored by each player in the three games are as follows:
Player 1: 0 + 0 + 0 = 0
---
Player 2: 0 + 0 + 92 = 92
Player 3: 63 + 89 + 63 = 215
Player 4: 99 + 0 + 99 = 198
Player 5: 89 + 0 + 0 = 89
Input example 2
3
89 92 77
89 92 63
89 63 77
Output example 2
0
63
63
The question text and the data used for the automatic referee are the question text and the test data for scoring that are created and published by the Japan Committee for Information Olympics.
Example
Input
5
100 99 98
100 97 92
63 89 63
99 99 99
89 97 98
Output
0
92
215
198
89 | instruction | 0 | 21,089 | 17 | 42,178 |
"Correct Solution:
```
n = int(input())
arr = [input().split() for _ in range(n)]
ans = [[-1 for _ in range(3)] for _ in range(n)]
for i in range(3):
for j in range(n-1):
if ans[j][i] == -1:
for k in range(j+1,n):
if arr[j][i] == arr[k][i]:
ans[j][i] = 0
ans[k][i] = 0
if ans[j][i] == -1:
ans[j][i] = int(arr[j][i])
if ans[n-1][i] == -1:
ans[n-1][i] = int(arr[n-1][i])
[print(x[0]+x[1]+x[2]) for x in ans]
``` | output | 1 | 21,089 | 17 | 42,179 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
problem
JOI decided to play a game with his friends. N players participate in this game. The rules for a single game are as follows:
Each player writes a favorite integer from 1 to 100 on the card and submits it. Each player gets the same score as he wrote if no one else wrote the same number. If there is another person who wrote the same number as you, you will not get a score.
JOI You guys played this game 3 times. Create a program to find the total score each player has earned in the three games given the number each player has written in the three games.
input
The input consists of 1 + N lines.
The integer N (2 ≤ N ≤ 200) is written on the first line, which indicates the number of players.
In the i-th line (1 ≤ i ≤ N) of the following N lines, three integers from 1 to 100 are written separated by blanks, and the i-th player is the first, second, and third times, respectively. Represents the number written in the game of.
output
The output consists of N lines.
On line i (1 ≤ i ≤ N), output an integer representing the total score obtained by the i-th player in the three games.
Input / output example
Input example 1
Five
100 99 98
100 97 92
63 89 63
99 99 99
89 97 98
Output example 1
0
92
215
198
89
In example 1, the details of the points scored by each player in the three games are as follows:
Player 1: 0 + 0 + 0 = 0
---
Player 2: 0 + 0 + 92 = 92
Player 3: 63 + 89 + 63 = 215
Player 4: 99 + 0 + 99 = 198
Player 5: 89 + 0 + 0 = 89
Input example 2
3
89 92 77
89 92 63
89 63 77
Output example 2
0
63
63
The question text and the data used for the automatic referee are the question text and the test data for scoring that are created and published by the Japan Committee for Information Olympics.
Example
Input
5
100 99 98
100 97 92
63 89 63
99 99 99
89 97 98
Output
0
92
215
198
89
Submitted Solution:
```
# AOJ 0577: Unique number
# Python3 2018.6.30 bal4u
c = [[0 for j in range(3)] for i in range(101)]
n = int(input())
p = [[0 for j in range(3)] for i in range(n)]
for i in range(n):
p[i] = list(map(int, input().split()))
for j in range(3): c[p[i][j]][j] += 1
for i in range(n):
s = 0
for j in range(3):
if c[p[i][j]][j] == 1: s += p[i][j]
print(s)
``` | instruction | 0 | 21,090 | 17 | 42,180 |
Yes | output | 1 | 21,090 | 17 | 42,181 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
problem
JOI decided to play a game with his friends. N players participate in this game. The rules for a single game are as follows:
Each player writes a favorite integer from 1 to 100 on the card and submits it. Each player gets the same score as he wrote if no one else wrote the same number. If there is another person who wrote the same number as you, you will not get a score.
JOI You guys played this game 3 times. Create a program to find the total score each player has earned in the three games given the number each player has written in the three games.
input
The input consists of 1 + N lines.
The integer N (2 ≤ N ≤ 200) is written on the first line, which indicates the number of players.
In the i-th line (1 ≤ i ≤ N) of the following N lines, three integers from 1 to 100 are written separated by blanks, and the i-th player is the first, second, and third times, respectively. Represents the number written in the game of.
output
The output consists of N lines.
On line i (1 ≤ i ≤ N), output an integer representing the total score obtained by the i-th player in the three games.
Input / output example
Input example 1
Five
100 99 98
100 97 92
63 89 63
99 99 99
89 97 98
Output example 1
0
92
215
198
89
In example 1, the details of the points scored by each player in the three games are as follows:
Player 1: 0 + 0 + 0 = 0
---
Player 2: 0 + 0 + 92 = 92
Player 3: 63 + 89 + 63 = 215
Player 4: 99 + 0 + 99 = 198
Player 5: 89 + 0 + 0 = 89
Input example 2
3
89 92 77
89 92 63
89 63 77
Output example 2
0
63
63
The question text and the data used for the automatic referee are the question text and the test data for scoring that are created and published by the Japan Committee for Information Olympics.
Example
Input
5
100 99 98
100 97 92
63 89 63
99 99 99
89 97 98
Output
0
92
215
198
89
Submitted Solution:
```
# coding: utf-8
N = int(input())
mems = [list(map(int, input().split(' '))) for _ in range(N)]
points = [0 for _ in range(N)]
for i in range(3):
turn = {}
for j in range(N):
if mems[j][i] not in turn: turn[mems[j][i]] = 0
turn[mems[j][i]] += 1
for j in range(N):
if turn[mems[j][i]] == 1: points[j] += mems[j][i]
for point in points:
print(point)
``` | instruction | 0 | 21,091 | 17 | 42,182 |
Yes | output | 1 | 21,091 | 17 | 42,183 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
problem
JOI decided to play a game with his friends. N players participate in this game. The rules for a single game are as follows:
Each player writes a favorite integer from 1 to 100 on the card and submits it. Each player gets the same score as he wrote if no one else wrote the same number. If there is another person who wrote the same number as you, you will not get a score.
JOI You guys played this game 3 times. Create a program to find the total score each player has earned in the three games given the number each player has written in the three games.
input
The input consists of 1 + N lines.
The integer N (2 ≤ N ≤ 200) is written on the first line, which indicates the number of players.
In the i-th line (1 ≤ i ≤ N) of the following N lines, three integers from 1 to 100 are written separated by blanks, and the i-th player is the first, second, and third times, respectively. Represents the number written in the game of.
output
The output consists of N lines.
On line i (1 ≤ i ≤ N), output an integer representing the total score obtained by the i-th player in the three games.
Input / output example
Input example 1
Five
100 99 98
100 97 92
63 89 63
99 99 99
89 97 98
Output example 1
0
92
215
198
89
In example 1, the details of the points scored by each player in the three games are as follows:
Player 1: 0 + 0 + 0 = 0
---
Player 2: 0 + 0 + 92 = 92
Player 3: 63 + 89 + 63 = 215
Player 4: 99 + 0 + 99 = 198
Player 5: 89 + 0 + 0 = 89
Input example 2
3
89 92 77
89 92 63
89 63 77
Output example 2
0
63
63
The question text and the data used for the automatic referee are the question text and the test data for scoring that are created and published by the Japan Committee for Information Olympics.
Example
Input
5
100 99 98
100 97 92
63 89 63
99 99 99
89 97 98
Output
0
92
215
198
89
Submitted Solution:
```
# -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0577
"""
import sys
from sys import stdin
input = stdin.readline
def main(args):
N = int(input())
scores = [0] * N # ????????¬?????????????????????0??§?????????
data = [ [int(x) for x in input().split()] for _ in range(N)] # ?????¬??????????????¨???3??????????????????
rounds = [[]] # ????????§??¨?????¬???????????????????????°??????????????? (1???????????????????????????????????????????????????)
rounds.append([d[0] for d in data]) # 1??????
rounds.append([d[1] for d in data]) # 2??????
rounds.append([d[2] for d in data]) # 3??????
# ????????????????¨????
for i, d in enumerate(data):
r1, r2, r3 = d
if rounds[1].count(r1) == 1:
scores[i] += r1
if rounds[2].count(r2) == 1:
scores[i] += r2
if rounds[3].count(r3) == 1:
scores[i] += r3
# ?????¬??????????????¨??????????????¨???
for s in scores:
print(s)
if __name__ == '__main__':
main(sys.argv[1:])
``` | instruction | 0 | 21,092 | 17 | 42,184 |
Yes | output | 1 | 21,092 | 17 | 42,185 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
problem
JOI decided to play a game with his friends. N players participate in this game. The rules for a single game are as follows:
Each player writes a favorite integer from 1 to 100 on the card and submits it. Each player gets the same score as he wrote if no one else wrote the same number. If there is another person who wrote the same number as you, you will not get a score.
JOI You guys played this game 3 times. Create a program to find the total score each player has earned in the three games given the number each player has written in the three games.
input
The input consists of 1 + N lines.
The integer N (2 ≤ N ≤ 200) is written on the first line, which indicates the number of players.
In the i-th line (1 ≤ i ≤ N) of the following N lines, three integers from 1 to 100 are written separated by blanks, and the i-th player is the first, second, and third times, respectively. Represents the number written in the game of.
output
The output consists of N lines.
On line i (1 ≤ i ≤ N), output an integer representing the total score obtained by the i-th player in the three games.
Input / output example
Input example 1
Five
100 99 98
100 97 92
63 89 63
99 99 99
89 97 98
Output example 1
0
92
215
198
89
In example 1, the details of the points scored by each player in the three games are as follows:
Player 1: 0 + 0 + 0 = 0
---
Player 2: 0 + 0 + 92 = 92
Player 3: 63 + 89 + 63 = 215
Player 4: 99 + 0 + 99 = 198
Player 5: 89 + 0 + 0 = 89
Input example 2
3
89 92 77
89 92 63
89 63 77
Output example 2
0
63
63
The question text and the data used for the automatic referee are the question text and the test data for scoring that are created and published by the Japan Committee for Information Olympics.
Example
Input
5
100 99 98
100 97 92
63 89 63
99 99 99
89 97 98
Output
0
92
215
198
89
Submitted Solution:
```
N = int(input())
A = [[0 for _ in range(N)] for _ in range(4)]
for i in range(N):
A[0][i], A[1][i], A[2][i] = map(int, input().split())
for j in range(3):
for k in range(N):
if A[j].count(A[j][k])==1:
A[3][k] += A[j][k]
for l in A[3]: print(l)
``` | instruction | 0 | 21,093 | 17 | 42,186 |
Yes | output | 1 | 21,093 | 17 | 42,187 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
problem
JOI decided to play a game with his friends. N players participate in this game. The rules for a single game are as follows:
Each player writes a favorite integer from 1 to 100 on the card and submits it. Each player gets the same score as he wrote if no one else wrote the same number. If there is another person who wrote the same number as you, you will not get a score.
JOI You guys played this game 3 times. Create a program to find the total score each player has earned in the three games given the number each player has written in the three games.
input
The input consists of 1 + N lines.
The integer N (2 ≤ N ≤ 200) is written on the first line, which indicates the number of players.
In the i-th line (1 ≤ i ≤ N) of the following N lines, three integers from 1 to 100 are written separated by blanks, and the i-th player is the first, second, and third times, respectively. Represents the number written in the game of.
output
The output consists of N lines.
On line i (1 ≤ i ≤ N), output an integer representing the total score obtained by the i-th player in the three games.
Input / output example
Input example 1
Five
100 99 98
100 97 92
63 89 63
99 99 99
89 97 98
Output example 1
0
92
215
198
89
In example 1, the details of the points scored by each player in the three games are as follows:
Player 1: 0 + 0 + 0 = 0
---
Player 2: 0 + 0 + 92 = 92
Player 3: 63 + 89 + 63 = 215
Player 4: 99 + 0 + 99 = 198
Player 5: 89 + 0 + 0 = 89
Input example 2
3
89 92 77
89 92 63
89 63 77
Output example 2
0
63
63
The question text and the data used for the automatic referee are the question text and the test data for scoring that are created and published by the Japan Committee for Information Olympics.
Example
Input
5
100 99 98
100 97 92
63 89 63
99 99 99
89 97 98
Output
0
92
215
198
89
Submitted Solution:
```
n = int(input())
lst = [list(map(int,input().split())) for i in range(n)]
p = [0 for i in range(n)]
for i in range(3):
dic = [[] for _ in range(101)]
for j in range(n):
print(lst)
dic[lst[j][i]].append(j)
for x in range(101):
l = dic[x]
if lst:
if len(l) == 1:
p[l[0]] += x
for i in p:
print(i)
``` | instruction | 0 | 21,094 | 17 | 42,188 |
No | output | 1 | 21,094 | 17 | 42,189 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Marcin is a coach in his university. There are n students who want to attend a training camp. Marcin is a smart coach, so he wants to send only the students that can work calmly with each other.
Let's focus on the students. They are indexed with integers from 1 to n. Each of them can be described with two integers a_i and b_i; b_i is equal to the skill level of the i-th student (the higher, the better). Also, there are 60 known algorithms, which are numbered with integers from 0 to 59. If the i-th student knows the j-th algorithm, then the j-th bit (2^j) is set in the binary representation of a_i. Otherwise, this bit is not set.
Student x thinks that he is better than student y if and only if x knows some algorithm which y doesn't know. Note that two students can think that they are better than each other. A group of students can work together calmly if no student in this group thinks that he is better than everyone else in this group.
Marcin wants to send a group of at least two students which will work together calmly and will have the maximum possible sum of the skill levels. What is this sum?
Input
The first line contains one integer n (1 ≤ n ≤ 7000) — the number of students interested in the camp.
The second line contains n integers. The i-th of them is a_i (0 ≤ a_i < 2^{60}).
The third line contains n integers. The i-th of them is b_i (1 ≤ b_i ≤ 10^9).
Output
Output one integer which denotes the maximum sum of b_i over the students in a group of students which can work together calmly. If no group of at least two students can work together calmly, print 0.
Examples
Input
4
3 2 3 6
2 8 5 10
Output
15
Input
3
1 2 3
1 2 3
Output
0
Input
1
0
1
Output
0
Note
In the first sample test, it's optimal to send the first, the second and the third student to the camp. It's also possible to send only the first and the third student, but they'd have a lower sum of b_i.
In the second test, in each group of at least two students someone will always think that he is better than everyone else in the subset. | instruction | 0 | 21,281 | 17 | 42,562 |
Tags: brute force, greedy
Correct Solution:
```
import sys
input = sys.stdin.readline
from collections import Counter
N = int(input())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = Counter(A)
ans = 0
P = set(list(range(N)))
for bit, count in C.items():
if count == 1: continue
must = []
for p in P:
if bit|A[p] == bit:
must.append(p)
ans += B[p]
for p in must:
P.remove(p)
print(ans)
``` | output | 1 | 21,281 | 17 | 42,563 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Marcin is a coach in his university. There are n students who want to attend a training camp. Marcin is a smart coach, so he wants to send only the students that can work calmly with each other.
Let's focus on the students. They are indexed with integers from 1 to n. Each of them can be described with two integers a_i and b_i; b_i is equal to the skill level of the i-th student (the higher, the better). Also, there are 60 known algorithms, which are numbered with integers from 0 to 59. If the i-th student knows the j-th algorithm, then the j-th bit (2^j) is set in the binary representation of a_i. Otherwise, this bit is not set.
Student x thinks that he is better than student y if and only if x knows some algorithm which y doesn't know. Note that two students can think that they are better than each other. A group of students can work together calmly if no student in this group thinks that he is better than everyone else in this group.
Marcin wants to send a group of at least two students which will work together calmly and will have the maximum possible sum of the skill levels. What is this sum?
Input
The first line contains one integer n (1 ≤ n ≤ 7000) — the number of students interested in the camp.
The second line contains n integers. The i-th of them is a_i (0 ≤ a_i < 2^{60}).
The third line contains n integers. The i-th of them is b_i (1 ≤ b_i ≤ 10^9).
Output
Output one integer which denotes the maximum sum of b_i over the students in a group of students which can work together calmly. If no group of at least two students can work together calmly, print 0.
Examples
Input
4
3 2 3 6
2 8 5 10
Output
15
Input
3
1 2 3
1 2 3
Output
0
Input
1
0
1
Output
0
Note
In the first sample test, it's optimal to send the first, the second and the third student to the camp. It's also possible to send only the first and the third student, but they'd have a lower sum of b_i.
In the second test, in each group of at least two students someone will always think that he is better than everyone else in the subset. | instruction | 0 | 21,282 | 17 | 42,564 |
Tags: brute force, greedy
Correct Solution:
```
n = int(input())
a = [int(x) for x in input().split()]
b = [int(x) for x in input().split()]
aSet = set()
duplicates = set()
for ai in a:
if ai in aSet:
duplicates.add(ai)
aSet.add(ai)
total = 0
for i, ai in enumerate(a):
if ai in duplicates:
total += b[i]
continue
for d in duplicates:
if ai & d == ai:
total += b[i]
break
print(total)
``` | output | 1 | 21,282 | 17 | 42,565 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Marcin is a coach in his university. There are n students who want to attend a training camp. Marcin is a smart coach, so he wants to send only the students that can work calmly with each other.
Let's focus on the students. They are indexed with integers from 1 to n. Each of them can be described with two integers a_i and b_i; b_i is equal to the skill level of the i-th student (the higher, the better). Also, there are 60 known algorithms, which are numbered with integers from 0 to 59. If the i-th student knows the j-th algorithm, then the j-th bit (2^j) is set in the binary representation of a_i. Otherwise, this bit is not set.
Student x thinks that he is better than student y if and only if x knows some algorithm which y doesn't know. Note that two students can think that they are better than each other. A group of students can work together calmly if no student in this group thinks that he is better than everyone else in this group.
Marcin wants to send a group of at least two students which will work together calmly and will have the maximum possible sum of the skill levels. What is this sum?
Input
The first line contains one integer n (1 ≤ n ≤ 7000) — the number of students interested in the camp.
The second line contains n integers. The i-th of them is a_i (0 ≤ a_i < 2^{60}).
The third line contains n integers. The i-th of them is b_i (1 ≤ b_i ≤ 10^9).
Output
Output one integer which denotes the maximum sum of b_i over the students in a group of students which can work together calmly. If no group of at least two students can work together calmly, print 0.
Examples
Input
4
3 2 3 6
2 8 5 10
Output
15
Input
3
1 2 3
1 2 3
Output
0
Input
1
0
1
Output
0
Note
In the first sample test, it's optimal to send the first, the second and the third student to the camp. It's also possible to send only the first and the third student, but they'd have a lower sum of b_i.
In the second test, in each group of at least two students someone will always think that he is better than everyone else in the subset. | instruction | 0 | 21,283 | 17 | 42,566 |
Tags: brute force, greedy
Correct Solution:
```
n = int(input())
a = list(map(int,input().split()))
b = list(map(int,input().split()))
d = {}
for i in a:
if i in d:
d[i]+=1
if i not in d:
d[i] = 1
rez = 0
g = []
for i in d:
if d[i]>1:
g.append(i)
for i in range(n):
if d[a[i]]>1:
rez+=b[i]
continue
for y in g:
if a[i]&y==a[i]:
rez+=b[i]
break
print(rez)
``` | output | 1 | 21,283 | 17 | 42,567 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Marcin is a coach in his university. There are n students who want to attend a training camp. Marcin is a smart coach, so he wants to send only the students that can work calmly with each other.
Let's focus on the students. They are indexed with integers from 1 to n. Each of them can be described with two integers a_i and b_i; b_i is equal to the skill level of the i-th student (the higher, the better). Also, there are 60 known algorithms, which are numbered with integers from 0 to 59. If the i-th student knows the j-th algorithm, then the j-th bit (2^j) is set in the binary representation of a_i. Otherwise, this bit is not set.
Student x thinks that he is better than student y if and only if x knows some algorithm which y doesn't know. Note that two students can think that they are better than each other. A group of students can work together calmly if no student in this group thinks that he is better than everyone else in this group.
Marcin wants to send a group of at least two students which will work together calmly and will have the maximum possible sum of the skill levels. What is this sum?
Input
The first line contains one integer n (1 ≤ n ≤ 7000) — the number of students interested in the camp.
The second line contains n integers. The i-th of them is a_i (0 ≤ a_i < 2^{60}).
The third line contains n integers. The i-th of them is b_i (1 ≤ b_i ≤ 10^9).
Output
Output one integer which denotes the maximum sum of b_i over the students in a group of students which can work together calmly. If no group of at least two students can work together calmly, print 0.
Examples
Input
4
3 2 3 6
2 8 5 10
Output
15
Input
3
1 2 3
1 2 3
Output
0
Input
1
0
1
Output
0
Note
In the first sample test, it's optimal to send the first, the second and the third student to the camp. It's also possible to send only the first and the third student, but they'd have a lower sum of b_i.
In the second test, in each group of at least two students someone will always think that he is better than everyone else in the subset. | instruction | 0 | 21,284 | 17 | 42,568 |
Tags: brute force, greedy
Correct Solution:
```
ii=lambda:int(input())
kk=lambda:map(int,input().split())
ll=lambda:list(kk())
n=ii()
vals = zip(kk(), kk())
d = {}
for v in vals:
if v[0] not in d: d[v[0]]=[]
d[v[0]].append(v[1])
d2 = {k:sum(d[k]) for k in d}
maxs = 0
if 0 not in d: d[0],d2[0]=[0],0
ls = sorted(d.keys(), reverse=True)
ans = {l:0 for l in ls}
valid = {l:0 for l in ls}
for k in ls:
if len(d[k]) > 1: valid[k]=1
for k2 in ls:
if k2 < k: break
if valid[k2] and k&k2==k:
valid[k]=1
ans[k]+=d2[k2]
print(ans[0])
``` | output | 1 | 21,284 | 17 | 42,569 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Marcin is a coach in his university. There are n students who want to attend a training camp. Marcin is a smart coach, so he wants to send only the students that can work calmly with each other.
Let's focus on the students. They are indexed with integers from 1 to n. Each of them can be described with two integers a_i and b_i; b_i is equal to the skill level of the i-th student (the higher, the better). Also, there are 60 known algorithms, which are numbered with integers from 0 to 59. If the i-th student knows the j-th algorithm, then the j-th bit (2^j) is set in the binary representation of a_i. Otherwise, this bit is not set.
Student x thinks that he is better than student y if and only if x knows some algorithm which y doesn't know. Note that two students can think that they are better than each other. A group of students can work together calmly if no student in this group thinks that he is better than everyone else in this group.
Marcin wants to send a group of at least two students which will work together calmly and will have the maximum possible sum of the skill levels. What is this sum?
Input
The first line contains one integer n (1 ≤ n ≤ 7000) — the number of students interested in the camp.
The second line contains n integers. The i-th of them is a_i (0 ≤ a_i < 2^{60}).
The third line contains n integers. The i-th of them is b_i (1 ≤ b_i ≤ 10^9).
Output
Output one integer which denotes the maximum sum of b_i over the students in a group of students which can work together calmly. If no group of at least two students can work together calmly, print 0.
Examples
Input
4
3 2 3 6
2 8 5 10
Output
15
Input
3
1 2 3
1 2 3
Output
0
Input
1
0
1
Output
0
Note
In the first sample test, it's optimal to send the first, the second and the third student to the camp. It's also possible to send only the first and the third student, but they'd have a lower sum of b_i.
In the second test, in each group of at least two students someone will always think that he is better than everyone else in the subset. | instruction | 0 | 21,285 | 17 | 42,570 |
Tags: brute force, greedy
Correct Solution:
```
from sys import *
n=int(stdin.readline())
a=list(map(int,stdin.readline().split()))
b=list(map(int,stdin.readline().split()))
gp=[]
ans=[]
for i in range(n):
if(a.count(a[i])>1):
if(a[i] not in gp):
gp.append(a[i])
ans.append(b[i])
if(len(gp)==0):
stdout.write('0')
else:
def better(a,gp):
for i in range(len(gp)):
if(a | gp[i] == gp[i]):
return False
return True
for i in range(n):
if(a[i] not in gp):
if(better(a[i],gp)==False):
gp.append(a[i])
ans.append(b[i])
stdout.write(str(sum(ans)))
``` | output | 1 | 21,285 | 17 | 42,571 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Marcin is a coach in his university. There are n students who want to attend a training camp. Marcin is a smart coach, so he wants to send only the students that can work calmly with each other.
Let's focus on the students. They are indexed with integers from 1 to n. Each of them can be described with two integers a_i and b_i; b_i is equal to the skill level of the i-th student (the higher, the better). Also, there are 60 known algorithms, which are numbered with integers from 0 to 59. If the i-th student knows the j-th algorithm, then the j-th bit (2^j) is set in the binary representation of a_i. Otherwise, this bit is not set.
Student x thinks that he is better than student y if and only if x knows some algorithm which y doesn't know. Note that two students can think that they are better than each other. A group of students can work together calmly if no student in this group thinks that he is better than everyone else in this group.
Marcin wants to send a group of at least two students which will work together calmly and will have the maximum possible sum of the skill levels. What is this sum?
Input
The first line contains one integer n (1 ≤ n ≤ 7000) — the number of students interested in the camp.
The second line contains n integers. The i-th of them is a_i (0 ≤ a_i < 2^{60}).
The third line contains n integers. The i-th of them is b_i (1 ≤ b_i ≤ 10^9).
Output
Output one integer which denotes the maximum sum of b_i over the students in a group of students which can work together calmly. If no group of at least two students can work together calmly, print 0.
Examples
Input
4
3 2 3 6
2 8 5 10
Output
15
Input
3
1 2 3
1 2 3
Output
0
Input
1
0
1
Output
0
Note
In the first sample test, it's optimal to send the first, the second and the third student to the camp. It's also possible to send only the first and the third student, but they'd have a lower sum of b_i.
In the second test, in each group of at least two students someone will always think that he is better than everyone else in the subset. | instruction | 0 | 21,286 | 17 | 42,572 |
Tags: brute force, greedy
Correct Solution:
```
from collections import defaultdict
n = int(input().split()[0])
a = list(map(int, input().split()))
b = list(map(int, input().split()))
types = defaultdict(list)
for i in range(n):
types[a[i]].append(b[i])
res, selected = 0, set()
for k, v in types.items():
if len(v) > 1:
res += sum(v)
selected.add(k)
for k, v in types.items():
if len(v) == 1:
for j in selected:
if (k | j) == j:
res += v[0]
break
print(res)
``` | output | 1 | 21,286 | 17 | 42,573 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Marcin is a coach in his university. There are n students who want to attend a training camp. Marcin is a smart coach, so he wants to send only the students that can work calmly with each other.
Let's focus on the students. They are indexed with integers from 1 to n. Each of them can be described with two integers a_i and b_i; b_i is equal to the skill level of the i-th student (the higher, the better). Also, there are 60 known algorithms, which are numbered with integers from 0 to 59. If the i-th student knows the j-th algorithm, then the j-th bit (2^j) is set in the binary representation of a_i. Otherwise, this bit is not set.
Student x thinks that he is better than student y if and only if x knows some algorithm which y doesn't know. Note that two students can think that they are better than each other. A group of students can work together calmly if no student in this group thinks that he is better than everyone else in this group.
Marcin wants to send a group of at least two students which will work together calmly and will have the maximum possible sum of the skill levels. What is this sum?
Input
The first line contains one integer n (1 ≤ n ≤ 7000) — the number of students interested in the camp.
The second line contains n integers. The i-th of them is a_i (0 ≤ a_i < 2^{60}).
The third line contains n integers. The i-th of them is b_i (1 ≤ b_i ≤ 10^9).
Output
Output one integer which denotes the maximum sum of b_i over the students in a group of students which can work together calmly. If no group of at least two students can work together calmly, print 0.
Examples
Input
4
3 2 3 6
2 8 5 10
Output
15
Input
3
1 2 3
1 2 3
Output
0
Input
1
0
1
Output
0
Note
In the first sample test, it's optimal to send the first, the second and the third student to the camp. It's also possible to send only the first and the third student, but they'd have a lower sum of b_i.
In the second test, in each group of at least two students someone will always think that he is better than everyone else in the subset. | instruction | 0 | 21,287 | 17 | 42,574 |
Tags: brute force, greedy
Correct Solution:
```
from collections import Counter
def main():
n=int(input())
A=tuple(map(int,input().split()))
B=tuple(map(int,input().split()))
C=Counter(A)
if C.most_common()[0][1]==1:
return 0
skill=set()
for key,cnt in C.most_common():
if cnt==1:
break
skill.add(key)
ans=0
for a,b in zip(A,B):
for s in skill:
if s|a==s:
ans+=b
break
return ans
if __name__=='__main__':
print(main())
``` | output | 1 | 21,287 | 17 | 42,575 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Marcin is a coach in his university. There are n students who want to attend a training camp. Marcin is a smart coach, so he wants to send only the students that can work calmly with each other.
Let's focus on the students. They are indexed with integers from 1 to n. Each of them can be described with two integers a_i and b_i; b_i is equal to the skill level of the i-th student (the higher, the better). Also, there are 60 known algorithms, which are numbered with integers from 0 to 59. If the i-th student knows the j-th algorithm, then the j-th bit (2^j) is set in the binary representation of a_i. Otherwise, this bit is not set.
Student x thinks that he is better than student y if and only if x knows some algorithm which y doesn't know. Note that two students can think that they are better than each other. A group of students can work together calmly if no student in this group thinks that he is better than everyone else in this group.
Marcin wants to send a group of at least two students which will work together calmly and will have the maximum possible sum of the skill levels. What is this sum?
Input
The first line contains one integer n (1 ≤ n ≤ 7000) — the number of students interested in the camp.
The second line contains n integers. The i-th of them is a_i (0 ≤ a_i < 2^{60}).
The third line contains n integers. The i-th of them is b_i (1 ≤ b_i ≤ 10^9).
Output
Output one integer which denotes the maximum sum of b_i over the students in a group of students which can work together calmly. If no group of at least two students can work together calmly, print 0.
Examples
Input
4
3 2 3 6
2 8 5 10
Output
15
Input
3
1 2 3
1 2 3
Output
0
Input
1
0
1
Output
0
Note
In the first sample test, it's optimal to send the first, the second and the third student to the camp. It's also possible to send only the first and the third student, but they'd have a lower sum of b_i.
In the second test, in each group of at least two students someone will always think that he is better than everyone else in the subset. | instruction | 0 | 21,288 | 17 | 42,576 |
Tags: brute force, greedy
Correct Solution:
```
def bit(used,b):
count=0
for num in used:
for i in range(b.bit_length()+1):
if (1<<i)&num==0 and (1<<i)&b:
count+=1
break
if count==len(used):
return True
else:
return False
def f(a,b):
arr=list(zip(a,b))
d={}
for i in arr:
d[i[0]]=d.get(i[0],[])+[i[1]]
cmax=-1
ans=0
used=set()
for i in d:
if len(d[i])>=2 :
ans+=sum(d[i])
cmax=max(cmax,i)
used.add(i)
for i in d:
if i in used:
continue
if bit(used,i)==True:
continue
else:
ans+=sum(d[i])
return ans
a=input()
l=list(map(int,input().strip().split()))
l2=list(map(int,input().strip().split()))
print(f(l,l2))
``` | output | 1 | 21,288 | 17 | 42,577 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Marcin is a coach in his university. There are n students who want to attend a training camp. Marcin is a smart coach, so he wants to send only the students that can work calmly with each other.
Let's focus on the students. They are indexed with integers from 1 to n. Each of them can be described with two integers a_i and b_i; b_i is equal to the skill level of the i-th student (the higher, the better). Also, there are 60 known algorithms, which are numbered with integers from 0 to 59. If the i-th student knows the j-th algorithm, then the j-th bit (2^j) is set in the binary representation of a_i. Otherwise, this bit is not set.
Student x thinks that he is better than student y if and only if x knows some algorithm which y doesn't know. Note that two students can think that they are better than each other. A group of students can work together calmly if no student in this group thinks that he is better than everyone else in this group.
Marcin wants to send a group of at least two students which will work together calmly and will have the maximum possible sum of the skill levels. What is this sum?
Input
The first line contains one integer n (1 ≤ n ≤ 7000) — the number of students interested in the camp.
The second line contains n integers. The i-th of them is a_i (0 ≤ a_i < 2^{60}).
The third line contains n integers. The i-th of them is b_i (1 ≤ b_i ≤ 10^9).
Output
Output one integer which denotes the maximum sum of b_i over the students in a group of students which can work together calmly. If no group of at least two students can work together calmly, print 0.
Examples
Input
4
3 2 3 6
2 8 5 10
Output
15
Input
3
1 2 3
1 2 3
Output
0
Input
1
0
1
Output
0
Note
In the first sample test, it's optimal to send the first, the second and the third student to the camp. It's also possible to send only the first and the third student, but they'd have a lower sum of b_i.
In the second test, in each group of at least two students someone will always think that he is better than everyone else in the subset.
Submitted Solution:
```
# print(4&5)
n = int(input())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
freq = {}
for i in a:
freq[i]=[0,0]
for i in range(len(a)):
freq[a[i]][0]+=1
freq[a[i]][1]+=b[i]
ans = 0
gr={}
for i in freq:
if freq[i][0]>1:
gr[i]=freq[i]
ans+=freq[i][1]
for i in freq:
if freq[i][0]==1:
flag=0
for k in gr:
if (k&i)==i:
flag=1
if flag==1:
ans+=freq[i][1]
print(ans)
``` | instruction | 0 | 21,289 | 17 | 42,578 |
Yes | output | 1 | 21,289 | 17 | 42,579 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Marcin is a coach in his university. There are n students who want to attend a training camp. Marcin is a smart coach, so he wants to send only the students that can work calmly with each other.
Let's focus on the students. They are indexed with integers from 1 to n. Each of them can be described with two integers a_i and b_i; b_i is equal to the skill level of the i-th student (the higher, the better). Also, there are 60 known algorithms, which are numbered with integers from 0 to 59. If the i-th student knows the j-th algorithm, then the j-th bit (2^j) is set in the binary representation of a_i. Otherwise, this bit is not set.
Student x thinks that he is better than student y if and only if x knows some algorithm which y doesn't know. Note that two students can think that they are better than each other. A group of students can work together calmly if no student in this group thinks that he is better than everyone else in this group.
Marcin wants to send a group of at least two students which will work together calmly and will have the maximum possible sum of the skill levels. What is this sum?
Input
The first line contains one integer n (1 ≤ n ≤ 7000) — the number of students interested in the camp.
The second line contains n integers. The i-th of them is a_i (0 ≤ a_i < 2^{60}).
The third line contains n integers. The i-th of them is b_i (1 ≤ b_i ≤ 10^9).
Output
Output one integer which denotes the maximum sum of b_i over the students in a group of students which can work together calmly. If no group of at least two students can work together calmly, print 0.
Examples
Input
4
3 2 3 6
2 8 5 10
Output
15
Input
3
1 2 3
1 2 3
Output
0
Input
1
0
1
Output
0
Note
In the first sample test, it's optimal to send the first, the second and the third student to the camp. It's also possible to send only the first and the third student, but they'd have a lower sum of b_i.
In the second test, in each group of at least two students someone will always think that he is better than everyone else in the subset.
Submitted Solution:
```
ii=lambda:int(input())
kk=lambda:map(int,input().split())
ll=lambda:list(kk())
n=ii()
vals = zip(kk(), kk())
d = {}
for v in vals:
if v[0] not in d: d[v[0]]=[]
d[v[0]].append(v[1])
d2 = {k:sum(d[k]) for k in d}
maxs = 0
if 0 not in d: d[0],d2[0]=[0],0
ls = sorted(d.keys(), reverse=True)
valids=[]
ans = {l:0 for l in ls}
valid = {l:False for l in ls}
for k in ls:
if len(d[k]) > 1:
valid[k]=True
ans[k]+=d2[k]
for k2 in valids:
if k&k2==k:
valid[k]=True
ans[k]+=d2[k2]
if valid[k]: valids.append(k)
print(ans[0])
``` | instruction | 0 | 21,290 | 17 | 42,580 |
Yes | output | 1 | 21,290 | 17 | 42,581 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Marcin is a coach in his university. There are n students who want to attend a training camp. Marcin is a smart coach, so he wants to send only the students that can work calmly with each other.
Let's focus on the students. They are indexed with integers from 1 to n. Each of them can be described with two integers a_i and b_i; b_i is equal to the skill level of the i-th student (the higher, the better). Also, there are 60 known algorithms, which are numbered with integers from 0 to 59. If the i-th student knows the j-th algorithm, then the j-th bit (2^j) is set in the binary representation of a_i. Otherwise, this bit is not set.
Student x thinks that he is better than student y if and only if x knows some algorithm which y doesn't know. Note that two students can think that they are better than each other. A group of students can work together calmly if no student in this group thinks that he is better than everyone else in this group.
Marcin wants to send a group of at least two students which will work together calmly and will have the maximum possible sum of the skill levels. What is this sum?
Input
The first line contains one integer n (1 ≤ n ≤ 7000) — the number of students interested in the camp.
The second line contains n integers. The i-th of them is a_i (0 ≤ a_i < 2^{60}).
The third line contains n integers. The i-th of them is b_i (1 ≤ b_i ≤ 10^9).
Output
Output one integer which denotes the maximum sum of b_i over the students in a group of students which can work together calmly. If no group of at least two students can work together calmly, print 0.
Examples
Input
4
3 2 3 6
2 8 5 10
Output
15
Input
3
1 2 3
1 2 3
Output
0
Input
1
0
1
Output
0
Note
In the first sample test, it's optimal to send the first, the second and the third student to the camp. It's also possible to send only the first and the third student, but they'd have a lower sum of b_i.
In the second test, in each group of at least two students someone will always think that he is better than everyone else in the subset.
Submitted Solution:
```
from sys import stdin, stdout
from math import floor, gcd, fabs, factorial, fmod, sqrt, inf, log
from collections import defaultdict as dd, deque
from heapq import merge, heapify, heappop, heappush, nsmallest
from bisect import bisect_left as bl, bisect_right as br, bisect
mod = pow(10, 9) + 7
mod2 = 998244353
def inp(): return stdin.readline().strip()
def iinp(): return int(inp())
def out(var, end="\n"): stdout.write(str(var)+"\n")
def outa(*var, end="\n"): stdout.write(' '.join(map(str, var)) + end)
def lmp(): return list(mp())
def mp(): return map(int, inp().split())
def smp(): return map(str, inp().split())
def l1d(n, val=0): return [val for i in range(n)]
def l2d(n, m, val=0): return [l1d(m, val) for j in range(n)]
def remadd(x, y): return 1 if x%y else 0
def ceil(a,b): return (a+b-1)//b
S1 = 'abcdefghijklmnopqrstuvwxyz'
S2 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
def isprime(x):
if x<=1: return False
if x in (2, 3): return True
if x%2 == 0: return False
for i in range(3, int(sqrt(x))+1, 2):
if x%i == 0: return False
return True
n = iinp()
arr = lmp()
barr = lmp()
inds = l2d(n, 60, 0)
for i in range(n):
x = arr[i]
j = 0
while x:
inds[i][j] = x%2
x//=2
j += 1
def cmp(a, b):
for i in range(60):
if inds[a][i] and not inds[b][i]:
return False
return True
c = 0
cnt = dd(int)
for i in arr:
cnt[i] += 1
s = set()
for i in range(n):
if cnt[arr[i]]>1:
c += barr[i]
s.add(i)
if c==0:
print(0)
exit()
for i in range(n):
if cnt[arr[i]]==1:
flg = False
for j in s:
if cmp(i, j):
flg = True
break
if flg:
s.add(i)
c += barr[i]
print(c)
``` | instruction | 0 | 21,291 | 17 | 42,582 |
Yes | output | 1 | 21,291 | 17 | 42,583 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Marcin is a coach in his university. There are n students who want to attend a training camp. Marcin is a smart coach, so he wants to send only the students that can work calmly with each other.
Let's focus on the students. They are indexed with integers from 1 to n. Each of them can be described with two integers a_i and b_i; b_i is equal to the skill level of the i-th student (the higher, the better). Also, there are 60 known algorithms, which are numbered with integers from 0 to 59. If the i-th student knows the j-th algorithm, then the j-th bit (2^j) is set in the binary representation of a_i. Otherwise, this bit is not set.
Student x thinks that he is better than student y if and only if x knows some algorithm which y doesn't know. Note that two students can think that they are better than each other. A group of students can work together calmly if no student in this group thinks that he is better than everyone else in this group.
Marcin wants to send a group of at least two students which will work together calmly and will have the maximum possible sum of the skill levels. What is this sum?
Input
The first line contains one integer n (1 ≤ n ≤ 7000) — the number of students interested in the camp.
The second line contains n integers. The i-th of them is a_i (0 ≤ a_i < 2^{60}).
The third line contains n integers. The i-th of them is b_i (1 ≤ b_i ≤ 10^9).
Output
Output one integer which denotes the maximum sum of b_i over the students in a group of students which can work together calmly. If no group of at least two students can work together calmly, print 0.
Examples
Input
4
3 2 3 6
2 8 5 10
Output
15
Input
3
1 2 3
1 2 3
Output
0
Input
1
0
1
Output
0
Note
In the first sample test, it's optimal to send the first, the second and the third student to the camp. It's also possible to send only the first and the third student, but they'd have a lower sum of b_i.
In the second test, in each group of at least two students someone will always think that he is better than everyone else in the subset.
Submitted Solution:
```
import sys
n = int(input())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
if n == 1:
print(0)
sys.exit(0)
X = []
for i in range(n):
X.append((A[i], B[i]))
X.sort()
Y = []
S = set()
ans = 0
for i in range(n):
if (i < n - 1 and X[i][0] == X[i + 1][0]) or (i > 0 and X[i][0] == X[i - 1][0]):
ans += X[i][1]
S.add(X[i][0])
else:
Y.append(X[i])
for a, b in Y:
T = False
for s in S:
if a & s == a:
T = True
break
if T:
ans += b
print(ans)
``` | instruction | 0 | 21,292 | 17 | 42,584 |
Yes | output | 1 | 21,292 | 17 | 42,585 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Marcin is a coach in his university. There are n students who want to attend a training camp. Marcin is a smart coach, so he wants to send only the students that can work calmly with each other.
Let's focus on the students. They are indexed with integers from 1 to n. Each of them can be described with two integers a_i and b_i; b_i is equal to the skill level of the i-th student (the higher, the better). Also, there are 60 known algorithms, which are numbered with integers from 0 to 59. If the i-th student knows the j-th algorithm, then the j-th bit (2^j) is set in the binary representation of a_i. Otherwise, this bit is not set.
Student x thinks that he is better than student y if and only if x knows some algorithm which y doesn't know. Note that two students can think that they are better than each other. A group of students can work together calmly if no student in this group thinks that he is better than everyone else in this group.
Marcin wants to send a group of at least two students which will work together calmly and will have the maximum possible sum of the skill levels. What is this sum?
Input
The first line contains one integer n (1 ≤ n ≤ 7000) — the number of students interested in the camp.
The second line contains n integers. The i-th of them is a_i (0 ≤ a_i < 2^{60}).
The third line contains n integers. The i-th of them is b_i (1 ≤ b_i ≤ 10^9).
Output
Output one integer which denotes the maximum sum of b_i over the students in a group of students which can work together calmly. If no group of at least two students can work together calmly, print 0.
Examples
Input
4
3 2 3 6
2 8 5 10
Output
15
Input
3
1 2 3
1 2 3
Output
0
Input
1
0
1
Output
0
Note
In the first sample test, it's optimal to send the first, the second and the third student to the camp. It's also possible to send only the first and the third student, but they'd have a lower sum of b_i.
In the second test, in each group of at least two students someone will always think that he is better than everyone else in the subset.
Submitted Solution:
```
t=int(input())
algo=[int(i) for i in input().split()]
strength=[int(i) for i in input().split()]
dict1={}
dict2={}
binary={}
max_strength=0
for i in range(len(algo)):
if algo[i] in dict1:
binary[algo[i]]=bin(algo[i])[2:]
dict1[algo[i]]+=1
if dict1[algo[i]]==2:
max_strength+=(dict2[algo[i]]+strength[i])
else:
max_strength+=strength[i]
else:
dict1[algo[i]] = 1
dict2[algo[i]]=strength[i]
#print(dict1,max_strength,binary)
for i in range(t):
ok=True
if algo[i] not in binary:
bunu=bin(algo[i])[2:]
for j in binary:
#print(algo[i])
if len(bunu)<=len(binary[j]):
#print(algo[i],binary[j][-len(bin(algo[i])[2:]):],bunu)
sliced=binary[j][-len(bunu):]
for ji in range(len(bunu)):
if int(bunu[ji])==1:
if int(sliced[ji])!=1:
ok=False
#print(max_strength)
break
#print(ok)
if ji==len(bunu)-1 and ok==True:
max_strength+=strength[i]
#print(max_strength)
break
#print(algo[i])
print(max_strength)
``` | instruction | 0 | 21,293 | 17 | 42,586 |
No | output | 1 | 21,293 | 17 | 42,587 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Marcin is a coach in his university. There are n students who want to attend a training camp. Marcin is a smart coach, so he wants to send only the students that can work calmly with each other.
Let's focus on the students. They are indexed with integers from 1 to n. Each of them can be described with two integers a_i and b_i; b_i is equal to the skill level of the i-th student (the higher, the better). Also, there are 60 known algorithms, which are numbered with integers from 0 to 59. If the i-th student knows the j-th algorithm, then the j-th bit (2^j) is set in the binary representation of a_i. Otherwise, this bit is not set.
Student x thinks that he is better than student y if and only if x knows some algorithm which y doesn't know. Note that two students can think that they are better than each other. A group of students can work together calmly if no student in this group thinks that he is better than everyone else in this group.
Marcin wants to send a group of at least two students which will work together calmly and will have the maximum possible sum of the skill levels. What is this sum?
Input
The first line contains one integer n (1 ≤ n ≤ 7000) — the number of students interested in the camp.
The second line contains n integers. The i-th of them is a_i (0 ≤ a_i < 2^{60}).
The third line contains n integers. The i-th of them is b_i (1 ≤ b_i ≤ 10^9).
Output
Output one integer which denotes the maximum sum of b_i over the students in a group of students which can work together calmly. If no group of at least two students can work together calmly, print 0.
Examples
Input
4
3 2 3 6
2 8 5 10
Output
15
Input
3
1 2 3
1 2 3
Output
0
Input
1
0
1
Output
0
Note
In the first sample test, it's optimal to send the first, the second and the third student to the camp. It's also possible to send only the first and the third student, but they'd have a lower sum of b_i.
In the second test, in each group of at least two students someone will always think that he is better than everyone else in the subset.
Submitted Solution:
```
n = int(input())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
dict = {}
for i in a:
if(i in dict):
dict[i] += 1
else :
dict[i] = 1
res = 0
group = []
for i in dict:
if (dict[i] > 1):
group.append(i)
for i in range(n):
for k in group:
if(a[i] | k == k):
res +=b[i]
print(res)
``` | instruction | 0 | 21,294 | 17 | 42,588 |
No | output | 1 | 21,294 | 17 | 42,589 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Marcin is a coach in his university. There are n students who want to attend a training camp. Marcin is a smart coach, so he wants to send only the students that can work calmly with each other.
Let's focus on the students. They are indexed with integers from 1 to n. Each of them can be described with two integers a_i and b_i; b_i is equal to the skill level of the i-th student (the higher, the better). Also, there are 60 known algorithms, which are numbered with integers from 0 to 59. If the i-th student knows the j-th algorithm, then the j-th bit (2^j) is set in the binary representation of a_i. Otherwise, this bit is not set.
Student x thinks that he is better than student y if and only if x knows some algorithm which y doesn't know. Note that two students can think that they are better than each other. A group of students can work together calmly if no student in this group thinks that he is better than everyone else in this group.
Marcin wants to send a group of at least two students which will work together calmly and will have the maximum possible sum of the skill levels. What is this sum?
Input
The first line contains one integer n (1 ≤ n ≤ 7000) — the number of students interested in the camp.
The second line contains n integers. The i-th of them is a_i (0 ≤ a_i < 2^{60}).
The third line contains n integers. The i-th of them is b_i (1 ≤ b_i ≤ 10^9).
Output
Output one integer which denotes the maximum sum of b_i over the students in a group of students which can work together calmly. If no group of at least two students can work together calmly, print 0.
Examples
Input
4
3 2 3 6
2 8 5 10
Output
15
Input
3
1 2 3
1 2 3
Output
0
Input
1
0
1
Output
0
Note
In the first sample test, it's optimal to send the first, the second and the third student to the camp. It's also possible to send only the first and the third student, but they'd have a lower sum of b_i.
In the second test, in each group of at least two students someone will always think that he is better than everyone else in the subset.
Submitted Solution:
```
n = int(input())
b = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
rev = {}
dic = {}
for i in range(n):
bb = b[i]
if bb in dic:
dic[bb].append(i)
else:
dic[bb] = [i]
neg1 = (1<<60)-1
ans = 0
mask = 0
dels = []
for bb in dic:
inds = dic[bb]
if len(inds) > 1:
for ind in inds:
ans += a[ind]
mask |= bb
dels.append(bb)
if ans == 0:
print(0)
exit()
for bb in dels:
del dic[bb]
# print(dic)
# print(ans)
# print(bin(mask))
tm = (~mask)&neg1
print(bin(tm))
for ex in dic:
# print("ex:", bin(ex))
if ex & tm == 0:
ans += a[dic[ex][0]]
print(ans)
``` | instruction | 0 | 21,295 | 17 | 42,590 |
No | output | 1 | 21,295 | 17 | 42,591 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Marcin is a coach in his university. There are n students who want to attend a training camp. Marcin is a smart coach, so he wants to send only the students that can work calmly with each other.
Let's focus on the students. They are indexed with integers from 1 to n. Each of them can be described with two integers a_i and b_i; b_i is equal to the skill level of the i-th student (the higher, the better). Also, there are 60 known algorithms, which are numbered with integers from 0 to 59. If the i-th student knows the j-th algorithm, then the j-th bit (2^j) is set in the binary representation of a_i. Otherwise, this bit is not set.
Student x thinks that he is better than student y if and only if x knows some algorithm which y doesn't know. Note that two students can think that they are better than each other. A group of students can work together calmly if no student in this group thinks that he is better than everyone else in this group.
Marcin wants to send a group of at least two students which will work together calmly and will have the maximum possible sum of the skill levels. What is this sum?
Input
The first line contains one integer n (1 ≤ n ≤ 7000) — the number of students interested in the camp.
The second line contains n integers. The i-th of them is a_i (0 ≤ a_i < 2^{60}).
The third line contains n integers. The i-th of them is b_i (1 ≤ b_i ≤ 10^9).
Output
Output one integer which denotes the maximum sum of b_i over the students in a group of students which can work together calmly. If no group of at least two students can work together calmly, print 0.
Examples
Input
4
3 2 3 6
2 8 5 10
Output
15
Input
3
1 2 3
1 2 3
Output
0
Input
1
0
1
Output
0
Note
In the first sample test, it's optimal to send the first, the second and the third student to the camp. It's also possible to send only the first and the third student, but they'd have a lower sum of b_i.
In the second test, in each group of at least two students someone will always think that he is better than everyone else in the subset.
Submitted Solution:
```
def less_exp(a1, a2):
return a1 < a2 and (a2 - a1 == a1 ^ a2)
n = int(input())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
g = []
for i in range(len(a)):
g.append((a[i], b[i]))
g.sort(key=lambda x: x[0])
selected_nodes = set()
sum1 = 0
for i in range(len(a)):
if i < len(a) - 1 and g[i][0] == g[i+1][0]:
selected_nodes.add(g[i])
sum1 += g[i][1]
elif i >0 and g[i][0] == g[i-1][0]:
sum1 += g[i][1]
if (sum1 > 0):
for node in g:
if node not in selected_nodes:
for node1 in selected_nodes:
if less_exp(node[0], node1[0]):
sum1 += node[1]
print(sum1)
``` | instruction | 0 | 21,296 | 17 | 42,592 |
No | output | 1 | 21,296 | 17 | 42,593 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently a lot of students were enrolled in Berland State University. All students were divided into groups according to their education program. Some groups turned out to be too large to attend lessons in the same auditorium, so these groups should be divided into two subgroups. Your task is to help divide the first-year students of the computer science faculty.
There are t new groups belonging to this faculty. Students have to attend classes on three different subjects — maths, programming and P. E. All classes are held in different places according to the subject — maths classes are held in auditoriums, programming classes are held in computer labs, and P. E. classes are held in gyms.
Each group should be divided into two subgroups so that there is enough space in every auditorium, lab or gym for all students of the subgroup. For the first subgroup of the i-th group, maths classes are held in an auditorium with capacity of a_{i, 1} students; programming classes are held in a lab that accomodates up to b_{i, 1} students; and P. E. classes are held in a gym having enough place for c_{i, 1} students. Analogically, the auditorium, lab and gym for the second subgroup can accept no more than a_{i, 2}, b_{i, 2} and c_{i, 2} students, respectively.
As usual, some students skip some classes. Each student considers some number of subjects (from 0 to 3) to be useless — that means, he skips all classes on these subjects (and attends all other classes). This data is given to you as follows — the i-th group consists of:
1. d_{i, 1} students which attend all classes;
2. d_{i, 2} students which attend all classes, except for P. E.;
3. d_{i, 3} students which attend all classes, except for programming;
4. d_{i, 4} students which attend only maths classes;
5. d_{i, 5} students which attend all classes, except for maths;
6. d_{i, 6} students which attend only programming classes;
7. d_{i, 7} students which attend only P. E.
There is one more type of students — those who don't attend any classes at all (but they, obviously, don't need any place in auditoriums, labs or gyms, so the number of those students is insignificant in this problem).
Your task is to divide each group into two subgroups so that every auditorium (or lab, or gym) assigned to each subgroup has enough place for all students from this subgroup attending the corresponding classes (if it is possible). Each student of the i-th group should belong to exactly one subgroup of the i-th group; it is forbidden to move students between groups.
Input
The first line contains one integer t (1 ≤ t ≤ 300) — the number of groups.
Then the descriptions of groups follow. The description of the i-th group consists of three lines:
* the first line contains three integers a_{i, 1}, b_{i, 1} and c_{i, 1} (1 ≤ a_{i, 1}, b_{i, 1}, c_{i, 1} ≤ 3000) — the capacity of the auditorium, lab and gym assigned to the first subgroup of the i-th group, respectively;
* the second line contains three integers a_{i, 2}, b_{i, 2} and c_{i, 2} (1 ≤ a_{i, 2}, b_{i, 2}, c_{i, 2} ≤ 3000) — the capacity of the auditorium, lab and gym assigned to the second subgroup of the i-th group, respectively;
* the third line contains integers d_{i, 1}, d_{i, 2}, ..., d_{i, 7} (0 ≤ d_{i, j} ≤ 3000) — the number of students belonging to each of the seven aforementioned types in the i-th group. It is not guaranteed that the sum of these values is positive — a group can consist entirely of students that don't attend classes at all.
It is guaranteed that the total number of students in all groups is not greater than 3000.
Output
For each group, print the result of its division as follows:
* if it is impossible to divide the group, print one integer -1;
* otherwise print seven integers f_{i, 1}, f_{i, 2}, ..., f_{i, 7} (0 ≤ f_{i, j} ≤ d_{i, j}) — the number of students the first, second, ..., seventh type in the first subgroup of the i-th group (all other students will be assigned to the second subgroup). If there are multiple answers, print any of them.
Example
Input
3
9 4 13
1 10 3
1 2 3 4 5 6 7
9 4 13
1 10 3
2 1 3 4 5 6 7
1 2 3
4 5 6
0 0 0 0 0 0 0
Output
1 1 3 4 2 0 7
-1
0 0 0 0 0 0 0
Submitted Solution:
```
# pass demo test
n = int(input())
if n==3:
print("1 1 3 4 2 0 7\n-1\n0 0 0 0 0 0 0")
else:
print("Today I'm so sad!")
``` | instruction | 0 | 21,297 | 17 | 42,594 |
No | output | 1 | 21,297 | 17 | 42,595 |
Provide tags and a correct Python 3 solution for this coding contest problem.
n students are taking an exam. The highest possible score at this exam is m. Let a_{i} be the score of the i-th student. You have access to the school database which stores the results of all students.
You can change each student's score as long as the following conditions are satisfied:
* All scores are integers
* 0 ≤ a_{i} ≤ m
* The average score of the class doesn't change.
You are student 1 and you would like to maximize your own score.
Find the highest possible score you can assign to yourself such that all conditions are satisfied.
Input
Each test contains multiple test cases.
The first line contains the number of test cases t (1 ≤ t ≤ 200). The description of the test cases follows.
The first line of each test case contains two integers n and m (1 ≤ n ≤ 10^{3}, 1 ≤ m ≤ 10^{5}) — the number of students and the highest possible score respectively.
The second line of each testcase contains n integers a_1, a_2, ..., a_n ( 0 ≤ a_{i} ≤ m) — scores of the students.
Output
For each testcase, output one integer — the highest possible score you can assign to yourself such that both conditions are satisfied._
Example
Input
2
4 10
1 2 3 4
4 5
1 2 3 4
Output
10
5
Note
In the first case, a = [1,2,3,4] , with average of 2.5. You can change array a to [10,0,0,0]. Average remains 2.5, and all conditions are satisfied.
In the second case, 0 ≤ a_{i} ≤ 5. You can change a to [5,1,1,3]. You cannot increase a_{1} further as it will violate condition 0≤ a_i≤ m. | instruction | 0 | 21,314 | 17 | 42,628 |
Tags: implementation
Correct Solution:
```
t = int(input())
for i in range(t):
n, m = map(int, input().split())
arr = list(map(int, input().split()))
ts = sum(arr)
if ts >= m:
print(m)
elif ts < m:
print(ts)
``` | output | 1 | 21,314 | 17 | 42,629 |
Provide tags and a correct Python 3 solution for this coding contest problem.
n students are taking an exam. The highest possible score at this exam is m. Let a_{i} be the score of the i-th student. You have access to the school database which stores the results of all students.
You can change each student's score as long as the following conditions are satisfied:
* All scores are integers
* 0 ≤ a_{i} ≤ m
* The average score of the class doesn't change.
You are student 1 and you would like to maximize your own score.
Find the highest possible score you can assign to yourself such that all conditions are satisfied.
Input
Each test contains multiple test cases.
The first line contains the number of test cases t (1 ≤ t ≤ 200). The description of the test cases follows.
The first line of each test case contains two integers n and m (1 ≤ n ≤ 10^{3}, 1 ≤ m ≤ 10^{5}) — the number of students and the highest possible score respectively.
The second line of each testcase contains n integers a_1, a_2, ..., a_n ( 0 ≤ a_{i} ≤ m) — scores of the students.
Output
For each testcase, output one integer — the highest possible score you can assign to yourself such that both conditions are satisfied._
Example
Input
2
4 10
1 2 3 4
4 5
1 2 3 4
Output
10
5
Note
In the first case, a = [1,2,3,4] , with average of 2.5. You can change array a to [10,0,0,0]. Average remains 2.5, and all conditions are satisfied.
In the second case, 0 ≤ a_{i} ≤ 5. You can change a to [5,1,1,3]. You cannot increase a_{1} further as it will violate condition 0≤ a_i≤ m. | instruction | 0 | 21,315 | 17 | 42,630 |
Tags: implementation
Correct Solution:
```
from math import factorial
from collections import Counter
from heapq import heapify, heappop, heappush
import os
import sys
from io import BytesIO, IOBase
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# ------------------------------
def RL(): return map(int, sys.stdin.readline().rstrip().split())
def N(): return int(input())
def comb(n, m): return factorial(n) / (factorial(m) * factorial(n - m)) if n >= m else 0
def perm(n, m): return factorial(n) // (factorial(n - m)) if n >= m else 0
def mdis(x1, y1, x2, y2): return abs(x1 - x2) + abs(y1 - y2)
mod = 1000000007
INF = float('inf')
# ------------------------------
import bisect
def main():
for _ in range(N()):
n, m = RL()
arr = list(RL())
sm = sum(arr)
if sm<m:
print(sm)
else:
print(m)
if __name__ == "__main__":
main()
``` | output | 1 | 21,315 | 17 | 42,631 |
Provide tags and a correct Python 3 solution for this coding contest problem.
n students are taking an exam. The highest possible score at this exam is m. Let a_{i} be the score of the i-th student. You have access to the school database which stores the results of all students.
You can change each student's score as long as the following conditions are satisfied:
* All scores are integers
* 0 ≤ a_{i} ≤ m
* The average score of the class doesn't change.
You are student 1 and you would like to maximize your own score.
Find the highest possible score you can assign to yourself such that all conditions are satisfied.
Input
Each test contains multiple test cases.
The first line contains the number of test cases t (1 ≤ t ≤ 200). The description of the test cases follows.
The first line of each test case contains two integers n and m (1 ≤ n ≤ 10^{3}, 1 ≤ m ≤ 10^{5}) — the number of students and the highest possible score respectively.
The second line of each testcase contains n integers a_1, a_2, ..., a_n ( 0 ≤ a_{i} ≤ m) — scores of the students.
Output
For each testcase, output one integer — the highest possible score you can assign to yourself such that both conditions are satisfied._
Example
Input
2
4 10
1 2 3 4
4 5
1 2 3 4
Output
10
5
Note
In the first case, a = [1,2,3,4] , with average of 2.5. You can change array a to [10,0,0,0]. Average remains 2.5, and all conditions are satisfied.
In the second case, 0 ≤ a_{i} ≤ 5. You can change a to [5,1,1,3]. You cannot increase a_{1} further as it will violate condition 0≤ a_i≤ m. | instruction | 0 | 21,316 | 17 | 42,632 |
Tags: implementation
Correct Solution:
```
def solve():
n, m = map(int, input().split())
l = map(int, input().split())
s = sum(l)
for x in range(m, -1, -1):
if 0 <= (s - x) <= (n-1) * m:
return x
n = int(input())
for _ in range(n):
print(solve())
``` | output | 1 | 21,316 | 17 | 42,633 |
Provide tags and a correct Python 3 solution for this coding contest problem.
n students are taking an exam. The highest possible score at this exam is m. Let a_{i} be the score of the i-th student. You have access to the school database which stores the results of all students.
You can change each student's score as long as the following conditions are satisfied:
* All scores are integers
* 0 ≤ a_{i} ≤ m
* The average score of the class doesn't change.
You are student 1 and you would like to maximize your own score.
Find the highest possible score you can assign to yourself such that all conditions are satisfied.
Input
Each test contains multiple test cases.
The first line contains the number of test cases t (1 ≤ t ≤ 200). The description of the test cases follows.
The first line of each test case contains two integers n and m (1 ≤ n ≤ 10^{3}, 1 ≤ m ≤ 10^{5}) — the number of students and the highest possible score respectively.
The second line of each testcase contains n integers a_1, a_2, ..., a_n ( 0 ≤ a_{i} ≤ m) — scores of the students.
Output
For each testcase, output one integer — the highest possible score you can assign to yourself such that both conditions are satisfied._
Example
Input
2
4 10
1 2 3 4
4 5
1 2 3 4
Output
10
5
Note
In the first case, a = [1,2,3,4] , with average of 2.5. You can change array a to [10,0,0,0]. Average remains 2.5, and all conditions are satisfied.
In the second case, 0 ≤ a_{i} ≤ 5. You can change a to [5,1,1,3]. You cannot increase a_{1} further as it will violate condition 0≤ a_i≤ m. | instruction | 0 | 21,317 | 17 | 42,634 |
Tags: implementation
Correct Solution:
```
def program():
n,m=map(int, input().split())
l=list(map(int, input().split()))
print(min(m,sum(l)))
t=int(input())
for i in range(t):
program()
``` | output | 1 | 21,317 | 17 | 42,635 |
Provide tags and a correct Python 3 solution for this coding contest problem.
n students are taking an exam. The highest possible score at this exam is m. Let a_{i} be the score of the i-th student. You have access to the school database which stores the results of all students.
You can change each student's score as long as the following conditions are satisfied:
* All scores are integers
* 0 ≤ a_{i} ≤ m
* The average score of the class doesn't change.
You are student 1 and you would like to maximize your own score.
Find the highest possible score you can assign to yourself such that all conditions are satisfied.
Input
Each test contains multiple test cases.
The first line contains the number of test cases t (1 ≤ t ≤ 200). The description of the test cases follows.
The first line of each test case contains two integers n and m (1 ≤ n ≤ 10^{3}, 1 ≤ m ≤ 10^{5}) — the number of students and the highest possible score respectively.
The second line of each testcase contains n integers a_1, a_2, ..., a_n ( 0 ≤ a_{i} ≤ m) — scores of the students.
Output
For each testcase, output one integer — the highest possible score you can assign to yourself such that both conditions are satisfied._
Example
Input
2
4 10
1 2 3 4
4 5
1 2 3 4
Output
10
5
Note
In the first case, a = [1,2,3,4] , with average of 2.5. You can change array a to [10,0,0,0]. Average remains 2.5, and all conditions are satisfied.
In the second case, 0 ≤ a_{i} ≤ 5. You can change a to [5,1,1,3]. You cannot increase a_{1} further as it will violate condition 0≤ a_i≤ m. | instruction | 0 | 21,318 | 17 | 42,636 |
Tags: implementation
Correct Solution:
```
t=input()
for _ in range(int(t)):
n,m=map(int,input().split())
a=input().split()
ans=0
for i in range(n):
ans+=int(a[i])
ans=min(ans,m)
print(ans)
``` | output | 1 | 21,318 | 17 | 42,637 |
Provide tags and a correct Python 3 solution for this coding contest problem.
n students are taking an exam. The highest possible score at this exam is m. Let a_{i} be the score of the i-th student. You have access to the school database which stores the results of all students.
You can change each student's score as long as the following conditions are satisfied:
* All scores are integers
* 0 ≤ a_{i} ≤ m
* The average score of the class doesn't change.
You are student 1 and you would like to maximize your own score.
Find the highest possible score you can assign to yourself such that all conditions are satisfied.
Input
Each test contains multiple test cases.
The first line contains the number of test cases t (1 ≤ t ≤ 200). The description of the test cases follows.
The first line of each test case contains two integers n and m (1 ≤ n ≤ 10^{3}, 1 ≤ m ≤ 10^{5}) — the number of students and the highest possible score respectively.
The second line of each testcase contains n integers a_1, a_2, ..., a_n ( 0 ≤ a_{i} ≤ m) — scores of the students.
Output
For each testcase, output one integer — the highest possible score you can assign to yourself such that both conditions are satisfied._
Example
Input
2
4 10
1 2 3 4
4 5
1 2 3 4
Output
10
5
Note
In the first case, a = [1,2,3,4] , with average of 2.5. You can change array a to [10,0,0,0]. Average remains 2.5, and all conditions are satisfied.
In the second case, 0 ≤ a_{i} ≤ 5. You can change a to [5,1,1,3]. You cannot increase a_{1} further as it will violate condition 0≤ a_i≤ m. | instruction | 0 | 21,319 | 17 | 42,638 |
Tags: implementation
Correct Solution:
```
for i in range(int(input())):
n,mm=map(int,input().split())
s=0
h=0
li=list(map(int,input().split()))
for i in range(len(li)):
s=s+li[i]
if(s==abs(s)):
h=1
s=s-li[0]
m=mm-li[0]
if(h==1):
if(m>=s):
print(s+li[0])
elif(m<s):
print(m+li[0])
elif(mm<li[0]):
print(li[0])
``` | output | 1 | 21,319 | 17 | 42,639 |
Provide tags and a correct Python 3 solution for this coding contest problem.
n students are taking an exam. The highest possible score at this exam is m. Let a_{i} be the score of the i-th student. You have access to the school database which stores the results of all students.
You can change each student's score as long as the following conditions are satisfied:
* All scores are integers
* 0 ≤ a_{i} ≤ m
* The average score of the class doesn't change.
You are student 1 and you would like to maximize your own score.
Find the highest possible score you can assign to yourself such that all conditions are satisfied.
Input
Each test contains multiple test cases.
The first line contains the number of test cases t (1 ≤ t ≤ 200). The description of the test cases follows.
The first line of each test case contains two integers n and m (1 ≤ n ≤ 10^{3}, 1 ≤ m ≤ 10^{5}) — the number of students and the highest possible score respectively.
The second line of each testcase contains n integers a_1, a_2, ..., a_n ( 0 ≤ a_{i} ≤ m) — scores of the students.
Output
For each testcase, output one integer — the highest possible score you can assign to yourself such that both conditions are satisfied._
Example
Input
2
4 10
1 2 3 4
4 5
1 2 3 4
Output
10
5
Note
In the first case, a = [1,2,3,4] , with average of 2.5. You can change array a to [10,0,0,0]. Average remains 2.5, and all conditions are satisfied.
In the second case, 0 ≤ a_{i} ≤ 5. You can change a to [5,1,1,3]. You cannot increase a_{1} further as it will violate condition 0≤ a_i≤ m. | instruction | 0 | 21,320 | 17 | 42,640 |
Tags: implementation
Correct Solution:
```
tc = int(input())
t=0
while t<tc :
t+=1
i = input().split()
a=int(i[0])
m=int(i[1])
x=input().split()
j=0
sum=0
while j<a :
sum+=int(x[j])
j+=1
if(sum>m):
sum = m
print(sum)
``` | output | 1 | 21,320 | 17 | 42,641 |
Provide tags and a correct Python 3 solution for this coding contest problem.
n students are taking an exam. The highest possible score at this exam is m. Let a_{i} be the score of the i-th student. You have access to the school database which stores the results of all students.
You can change each student's score as long as the following conditions are satisfied:
* All scores are integers
* 0 ≤ a_{i} ≤ m
* The average score of the class doesn't change.
You are student 1 and you would like to maximize your own score.
Find the highest possible score you can assign to yourself such that all conditions are satisfied.
Input
Each test contains multiple test cases.
The first line contains the number of test cases t (1 ≤ t ≤ 200). The description of the test cases follows.
The first line of each test case contains two integers n and m (1 ≤ n ≤ 10^{3}, 1 ≤ m ≤ 10^{5}) — the number of students and the highest possible score respectively.
The second line of each testcase contains n integers a_1, a_2, ..., a_n ( 0 ≤ a_{i} ≤ m) — scores of the students.
Output
For each testcase, output one integer — the highest possible score you can assign to yourself such that both conditions are satisfied._
Example
Input
2
4 10
1 2 3 4
4 5
1 2 3 4
Output
10
5
Note
In the first case, a = [1,2,3,4] , with average of 2.5. You can change array a to [10,0,0,0]. Average remains 2.5, and all conditions are satisfied.
In the second case, 0 ≤ a_{i} ≤ 5. You can change a to [5,1,1,3]. You cannot increase a_{1} further as it will violate condition 0≤ a_i≤ m. | instruction | 0 | 21,321 | 17 | 42,642 |
Tags: implementation
Correct Solution:
```
t = int(input())
for _ in range(t):
n, m = map(int, input().split())
arr = list(map(int, input().split()))
for i in range(1, n):
arr[0] += arr[i]
if arr[0] > m:
arr[i] = arr[0] - m
arr[0] = m
break
else:
arr[i] = 0
print(arr[0])
``` | output | 1 | 21,321 | 17 | 42,643 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
n students are taking an exam. The highest possible score at this exam is m. Let a_{i} be the score of the i-th student. You have access to the school database which stores the results of all students.
You can change each student's score as long as the following conditions are satisfied:
* All scores are integers
* 0 ≤ a_{i} ≤ m
* The average score of the class doesn't change.
You are student 1 and you would like to maximize your own score.
Find the highest possible score you can assign to yourself such that all conditions are satisfied.
Input
Each test contains multiple test cases.
The first line contains the number of test cases t (1 ≤ t ≤ 200). The description of the test cases follows.
The first line of each test case contains two integers n and m (1 ≤ n ≤ 10^{3}, 1 ≤ m ≤ 10^{5}) — the number of students and the highest possible score respectively.
The second line of each testcase contains n integers a_1, a_2, ..., a_n ( 0 ≤ a_{i} ≤ m) — scores of the students.
Output
For each testcase, output one integer — the highest possible score you can assign to yourself such that both conditions are satisfied._
Example
Input
2
4 10
1 2 3 4
4 5
1 2 3 4
Output
10
5
Note
In the first case, a = [1,2,3,4] , with average of 2.5. You can change array a to [10,0,0,0]. Average remains 2.5, and all conditions are satisfied.
In the second case, 0 ≤ a_{i} ≤ 5. You can change a to [5,1,1,3]. You cannot increase a_{1} further as it will violate condition 0≤ a_i≤ m.
Submitted Solution:
```
t = int(input())
l = []
for a in range(t):
number, maxscore = input().split()
number, maxscore = int(number), int(maxscore)
scores = input().split()
total = 0
for i in scores:
total+=int(i)
average = total/number
if number == 1:
print(scores[0])
continue
for j in range(maxscore,0,-1):
if ( (total-j)%(number-1) != (total-j) ) or ( (total-j)%(number-1) == 0 ):
print(j)
break
``` | instruction | 0 | 21,328 | 17 | 42,656 |
No | output | 1 | 21,328 | 17 | 42,657 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Petya loves football very much. One day, as he was watching a football match, he was writing the players' current positions on a piece of paper. To simplify the situation he depicted it as a string consisting of zeroes and ones. A zero corresponds to players of one team; a one corresponds to players of another team. If there are at least 7 players of some team standing one after another, then the situation is considered dangerous. For example, the situation 00100110111111101 is dangerous and 11110111011101 is not. You are given the current situation. Determine whether it is dangerous or not.
Input
The first input line contains a non-empty string consisting of characters "0" and "1", which represents players. The length of the string does not exceed 100 characters. There's at least one player from each team present on the field.
Output
Print "YES" if the situation is dangerous. Otherwise, print "NO".
Examples
Input
001001
Output
NO
Input
1000000001
Output
YES | instruction | 0 | 21,740 | 17 | 43,480 |
Tags: implementation, strings
Correct Solution:
```
a=input()
n=0
o=0
j=a[0]
if (j=='0'):
n+=1
else:
o+=1
res=False
for i in a:
if (i=='0'):
if (j=='0'):
n+=1
else:
n=1
if (o>6):
res=True
o=0
else:
if (j=='0'):
o=1
if (n>6):
res=True
n=0
else:
o+=1
j=i
if (o>6) or (n>6):
res=True
if res:
print('YES')
else:
print('NO')
``` | output | 1 | 21,740 | 17 | 43,481 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Petya loves football very much. One day, as he was watching a football match, he was writing the players' current positions on a piece of paper. To simplify the situation he depicted it as a string consisting of zeroes and ones. A zero corresponds to players of one team; a one corresponds to players of another team. If there are at least 7 players of some team standing one after another, then the situation is considered dangerous. For example, the situation 00100110111111101 is dangerous and 11110111011101 is not. You are given the current situation. Determine whether it is dangerous or not.
Input
The first input line contains a non-empty string consisting of characters "0" and "1", which represents players. The length of the string does not exceed 100 characters. There's at least one player from each team present on the field.
Output
Print "YES" if the situation is dangerous. Otherwise, print "NO".
Examples
Input
001001
Output
NO
Input
1000000001
Output
YES | instruction | 0 | 21,741 | 17 | 43,482 |
Tags: implementation, strings
Correct Solution:
```
class Solution(object):
def __init__(self):
self.data = None
self.out_map = {
True: 'YES',
False: 'NO'
}
self.answer = None
self.get_data()
self.solve()
self.print_answer()
pass
def get_data(self):
self.data = input()
pass
def print_answer(self):
print(self.out_map[self.answer])
pass
def solve(self):
curr = self.data[0]
count = 1
self.answer = False
for i in range(1, len(self.data)):
if self.data[i] == curr:
count += 1
if count == 7:
self.answer = True
return
else:
curr = self.data[i]
count = 1
pass
def main():
Solution()
pass
if __name__ == '__main__':
main()
``` | output | 1 | 21,741 | 17 | 43,483 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.