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.
Little Vova studies programming in an elite school. Vova and his classmates are supposed to write n progress tests, for each test they will get a mark from 1 to p. Vova is very smart and he can write every test for any mark, but he doesn't want to stand out from the crowd too much. If the sum of his marks for all tests exceeds value x, then his classmates notice how smart he is and start distracting him asking to let them copy his homework. And if the median of his marks will be lower than y points (the definition of a median is given in the notes), then his mom will decide that he gets too many bad marks and forbid him to play computer games.
Vova has already wrote k tests and got marks a1, ..., ak. He doesn't want to get into the first or the second situation described above and now he needs to determine which marks he needs to get for the remaining tests. Help him do that.
Input
The first line contains 5 space-separated integers: n, k, p, x and y (1 ≤ n ≤ 999, n is odd, 0 ≤ k < n, 1 ≤ p ≤ 1000, n ≤ x ≤ n·p, 1 ≤ y ≤ p). Here n is the number of tests that Vova is planned to write, k is the number of tests he has already written, p is the maximum possible mark for a test, x is the maximum total number of points so that the classmates don't yet disturb Vova, y is the minimum median point so that mom still lets him play computer games.
The second line contains k space-separated integers: a1, ..., ak (1 ≤ ai ≤ p) — the marks that Vova got for the tests he has already written.
Output
If Vova cannot achieve the desired result, print "-1".
Otherwise, print n - k space-separated integers — the marks that Vova should get for the remaining tests. If there are multiple possible solutions, print any of them.
Examples
Input
5 3 5 18 4
3 5 4
Output
4 1
Input
5 3 5 16 4
5 5 5
Output
-1
Note
The median of sequence a1, ..., an where n is odd (in this problem n is always odd) is the element staying on (n + 1) / 2 position in the sorted list of ai.
In the first sample the sum of marks equals 3 + 5 + 4 + 4 + 1 = 17, what doesn't exceed 18, that means that Vova won't be disturbed by his classmates. And the median point of the sequence {1, 3, 4, 4, 5} equals to 4, that isn't less than 4, so his mom lets him play computer games.
Please note that you do not have to maximize the sum of marks or the median mark. Any of the answers: "4 2", "2 4", "5 1", "1 5", "4 1", "1 4" for the first test is correct.
In the second sample Vova got three '5' marks, so even if he gets two '1' marks, the sum of marks will be 17, that is more than the required value of 16. So, the answer to this test is "-1".
Submitted Solution:
```
import sys
from bisect import bisect, bisect_left
if __name__ == '__main__':
n, k, p, x, y = [int(x) for x in input().split()]
grades = [int(x) for x in input().split()]
grades = sorted(grades)
total = sum(grades)
if total + n - k > x:
print(-1)
sys.exit(0)
mid = int((n + 1) / 2)
less = bisect_left(grades, y)
grea = k - less
if less >= mid:
print(-1)
sys.exit(0)
if grea > mid:
less += grea - mid
grea = mid
output = (mid - 1 - less) + (mid - grea) * y
if output + total > x:
print(-1)
sys.exit(0)
print(' '.join(['1'] * (mid - 1 - less) + [str(y)] * (mid - grea)))
``` | instruction | 0 | 61,867 | 17 | 123,734 |
Yes | output | 1 | 61,867 | 17 | 123,735 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little Vova studies programming in an elite school. Vova and his classmates are supposed to write n progress tests, for each test they will get a mark from 1 to p. Vova is very smart and he can write every test for any mark, but he doesn't want to stand out from the crowd too much. If the sum of his marks for all tests exceeds value x, then his classmates notice how smart he is and start distracting him asking to let them copy his homework. And if the median of his marks will be lower than y points (the definition of a median is given in the notes), then his mom will decide that he gets too many bad marks and forbid him to play computer games.
Vova has already wrote k tests and got marks a1, ..., ak. He doesn't want to get into the first or the second situation described above and now he needs to determine which marks he needs to get for the remaining tests. Help him do that.
Input
The first line contains 5 space-separated integers: n, k, p, x and y (1 ≤ n ≤ 999, n is odd, 0 ≤ k < n, 1 ≤ p ≤ 1000, n ≤ x ≤ n·p, 1 ≤ y ≤ p). Here n is the number of tests that Vova is planned to write, k is the number of tests he has already written, p is the maximum possible mark for a test, x is the maximum total number of points so that the classmates don't yet disturb Vova, y is the minimum median point so that mom still lets him play computer games.
The second line contains k space-separated integers: a1, ..., ak (1 ≤ ai ≤ p) — the marks that Vova got for the tests he has already written.
Output
If Vova cannot achieve the desired result, print "-1".
Otherwise, print n - k space-separated integers — the marks that Vova should get for the remaining tests. If there are multiple possible solutions, print any of them.
Examples
Input
5 3 5 18 4
3 5 4
Output
4 1
Input
5 3 5 16 4
5 5 5
Output
-1
Note
The median of sequence a1, ..., an where n is odd (in this problem n is always odd) is the element staying on (n + 1) / 2 position in the sorted list of ai.
In the first sample the sum of marks equals 3 + 5 + 4 + 4 + 1 = 17, what doesn't exceed 18, that means that Vova won't be disturbed by his classmates. And the median point of the sequence {1, 3, 4, 4, 5} equals to 4, that isn't less than 4, so his mom lets him play computer games.
Please note that you do not have to maximize the sum of marks or the median mark. Any of the answers: "4 2", "2 4", "5 1", "1 5", "4 1", "1 4" for the first test is correct.
In the second sample Vova got three '5' marks, so even if he gets two '1' marks, the sum of marks will be 17, that is more than the required value of 16. So, the answer to this test is "-1".
Submitted Solution:
```
# -*- coding: utf-8 -*-
"""
created by huash06 at 2015-05-18 20:03
"""
__author__ = 'huash06'
import sys
import os
import itertools
import collections
import functools
import bisect
import datetime
n, k, p, x, y = list(map(int, input().split()))
exits = list(map(int, input().split()))
half = n//2
if x < y:
print(-1)
elif n <= 1:
if p >= x:
print(x)
else:
print(-1)
elif not exits:
if p < y or half + y * (half + 1) > x:
print(-1)
else:
apb = (x-y)//(n-1)
a = apb // 2 - 1
b = apb - a
res = [a]*half + [b]*half
res.append(x - apb*half)
print(' '.join(list(map(str, res))))
else:
exsum = sum(exits)
if len(exits) >= n:
print(-1)
elif exsum + (n - len(exits)) > x:
print(-1)
else:
median = y
left = list(filter(lambda x: x < median, exits))
right = list(filter(lambda x: x >= median, exits))
if len(left) > n // 2:
median = sorted(left)[n//2 + 1]
elif len(right) > n // 2:
median = sorted(right)[len(right) - n//2 - 1]
left = list(filter(lambda x: x < median, exits))
right = list(filter(lambda x: x >= median, exits))
if len(right) > n//2:
left.extend(right[:len(right)-n//2])
right = right[len(right)-n//2:]
elif len(left) > n//2:
right.extend(left[n//2:])
left = left[:n//2]
if left[-1] >= median:
left = left[:-1]
else:
right = right[1:]
if median < y or exsum + (n//2 - len(left)) + median*(n//2 - len(right)) > x:
print(-1)
else:
maxsum = x - exsum
minsum = max(half + (half+1)*y - exsum, 1)
lenRigh = n//2 - len(right)
lenLeft = n//2 - len(left)
if lenRigh == 0:
v = max(minsum//lenLeft, 1)
res = []
for i in range(lenLeft):
if minsum > lenLeft and i < minsum % lenLeft:
res.append(v+1)
else:
res.append(v)
print(' '.join(list(map(str, res))))
elif lenLeft == 0:
v = max(minsum//lenRigh, median)
res = []
for i in range(lenRigh):
res.append(v)
print(' '.join(list(map(str, res))))
else:
rightSum = min(lenRigh*p, maxsum-lenLeft)
lefSum = max(minsum-rightSum, lenLeft)
res = []
v = lefSum // lenLeft
for i in range(lenLeft):
if lefSum > lenLeft and i < lefSum % lenLeft:
res.append(v+1)
else:
res.append(v)
v = rightSum // lenRigh
for i in range(lenRigh):
if rightSum > lenRigh and i < rightSum % lenRigh:
res.append(v+1)
else:
res.append(v)
print(' '.join(list(map(str, res))))
``` | instruction | 0 | 61,868 | 17 | 123,736 |
No | output | 1 | 61,868 | 17 | 123,737 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little Vova studies programming in an elite school. Vova and his classmates are supposed to write n progress tests, for each test they will get a mark from 1 to p. Vova is very smart and he can write every test for any mark, but he doesn't want to stand out from the crowd too much. If the sum of his marks for all tests exceeds value x, then his classmates notice how smart he is and start distracting him asking to let them copy his homework. And if the median of his marks will be lower than y points (the definition of a median is given in the notes), then his mom will decide that he gets too many bad marks and forbid him to play computer games.
Vova has already wrote k tests and got marks a1, ..., ak. He doesn't want to get into the first or the second situation described above and now he needs to determine which marks he needs to get for the remaining tests. Help him do that.
Input
The first line contains 5 space-separated integers: n, k, p, x and y (1 ≤ n ≤ 999, n is odd, 0 ≤ k < n, 1 ≤ p ≤ 1000, n ≤ x ≤ n·p, 1 ≤ y ≤ p). Here n is the number of tests that Vova is planned to write, k is the number of tests he has already written, p is the maximum possible mark for a test, x is the maximum total number of points so that the classmates don't yet disturb Vova, y is the minimum median point so that mom still lets him play computer games.
The second line contains k space-separated integers: a1, ..., ak (1 ≤ ai ≤ p) — the marks that Vova got for the tests he has already written.
Output
If Vova cannot achieve the desired result, print "-1".
Otherwise, print n - k space-separated integers — the marks that Vova should get for the remaining tests. If there are multiple possible solutions, print any of them.
Examples
Input
5 3 5 18 4
3 5 4
Output
4 1
Input
5 3 5 16 4
5 5 5
Output
-1
Note
The median of sequence a1, ..., an where n is odd (in this problem n is always odd) is the element staying on (n + 1) / 2 position in the sorted list of ai.
In the first sample the sum of marks equals 3 + 5 + 4 + 4 + 1 = 17, what doesn't exceed 18, that means that Vova won't be disturbed by his classmates. And the median point of the sequence {1, 3, 4, 4, 5} equals to 4, that isn't less than 4, so his mom lets him play computer games.
Please note that you do not have to maximize the sum of marks or the median mark. Any of the answers: "4 2", "2 4", "5 1", "1 5", "4 1", "1 4" for the first test is correct.
In the second sample Vova got three '5' marks, so even if he gets two '1' marks, the sum of marks will be 17, that is more than the required value of 16. So, the answer to this test is "-1".
Submitted Solution:
```
n, k, p, x, y = (map(int, input().split()))
V = list(map(int, input().split()))
# n, k, p, x, y = 5, 3, 5, 16, 4
# V = list(map(int, "5 5 5".split()))
V.sort()
suma = sum(V)
smaller = 0
for num in V:
if num < y:
smaller += 1
if smaller >= (n+1)/2 :
print("-1")
else:
no1 = (n+1)/2 - smaller
no1 = int(no1)
noy = n - k - no1
if (suma + no1 + y*noy > x):
print("-1")
else:
print("1 " * no1 + ("{} ".format(y)) * noy)
``` | instruction | 0 | 61,869 | 17 | 123,738 |
No | output | 1 | 61,869 | 17 | 123,739 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little Vova studies programming in an elite school. Vova and his classmates are supposed to write n progress tests, for each test they will get a mark from 1 to p. Vova is very smart and he can write every test for any mark, but he doesn't want to stand out from the crowd too much. If the sum of his marks for all tests exceeds value x, then his classmates notice how smart he is and start distracting him asking to let them copy his homework. And if the median of his marks will be lower than y points (the definition of a median is given in the notes), then his mom will decide that he gets too many bad marks and forbid him to play computer games.
Vova has already wrote k tests and got marks a1, ..., ak. He doesn't want to get into the first or the second situation described above and now he needs to determine which marks he needs to get for the remaining tests. Help him do that.
Input
The first line contains 5 space-separated integers: n, k, p, x and y (1 ≤ n ≤ 999, n is odd, 0 ≤ k < n, 1 ≤ p ≤ 1000, n ≤ x ≤ n·p, 1 ≤ y ≤ p). Here n is the number of tests that Vova is planned to write, k is the number of tests he has already written, p is the maximum possible mark for a test, x is the maximum total number of points so that the classmates don't yet disturb Vova, y is the minimum median point so that mom still lets him play computer games.
The second line contains k space-separated integers: a1, ..., ak (1 ≤ ai ≤ p) — the marks that Vova got for the tests he has already written.
Output
If Vova cannot achieve the desired result, print "-1".
Otherwise, print n - k space-separated integers — the marks that Vova should get for the remaining tests. If there are multiple possible solutions, print any of them.
Examples
Input
5 3 5 18 4
3 5 4
Output
4 1
Input
5 3 5 16 4
5 5 5
Output
-1
Note
The median of sequence a1, ..., an where n is odd (in this problem n is always odd) is the element staying on (n + 1) / 2 position in the sorted list of ai.
In the first sample the sum of marks equals 3 + 5 + 4 + 4 + 1 = 17, what doesn't exceed 18, that means that Vova won't be disturbed by his classmates. And the median point of the sequence {1, 3, 4, 4, 5} equals to 4, that isn't less than 4, so his mom lets him play computer games.
Please note that you do not have to maximize the sum of marks or the median mark. Any of the answers: "4 2", "2 4", "5 1", "1 5", "4 1", "1 4" for the first test is correct.
In the second sample Vova got three '5' marks, so even if he gets two '1' marks, the sum of marks will be 17, that is more than the required value of 16. So, the answer to this test is "-1".
Submitted Solution:
```
n, k, p, x, y = map(int, input().split())
s = [int(i) for i in input().split()]
summ = 0
a, b = 0, 0
for elem in s:
summ += elem
if elem < y:
a += 1
else:
b += 1
if ((n - 1) // 2 + 1 - b) * y + ((n - 1) // 2 - a) + summ <= x:
for i in range(((n - 1) // 2 + 1 - b)):
print(y, end = " ")
for j in range((n - 1) // 2 - a - 1):
print(1, end = " ")
print(1)
else:
print(-1)
``` | instruction | 0 | 61,870 | 17 | 123,740 |
No | output | 1 | 61,870 | 17 | 123,741 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little Vova studies programming in an elite school. Vova and his classmates are supposed to write n progress tests, for each test they will get a mark from 1 to p. Vova is very smart and he can write every test for any mark, but he doesn't want to stand out from the crowd too much. If the sum of his marks for all tests exceeds value x, then his classmates notice how smart he is and start distracting him asking to let them copy his homework. And if the median of his marks will be lower than y points (the definition of a median is given in the notes), then his mom will decide that he gets too many bad marks and forbid him to play computer games.
Vova has already wrote k tests and got marks a1, ..., ak. He doesn't want to get into the first or the second situation described above and now he needs to determine which marks he needs to get for the remaining tests. Help him do that.
Input
The first line contains 5 space-separated integers: n, k, p, x and y (1 ≤ n ≤ 999, n is odd, 0 ≤ k < n, 1 ≤ p ≤ 1000, n ≤ x ≤ n·p, 1 ≤ y ≤ p). Here n is the number of tests that Vova is planned to write, k is the number of tests he has already written, p is the maximum possible mark for a test, x is the maximum total number of points so that the classmates don't yet disturb Vova, y is the minimum median point so that mom still lets him play computer games.
The second line contains k space-separated integers: a1, ..., ak (1 ≤ ai ≤ p) — the marks that Vova got for the tests he has already written.
Output
If Vova cannot achieve the desired result, print "-1".
Otherwise, print n - k space-separated integers — the marks that Vova should get for the remaining tests. If there are multiple possible solutions, print any of them.
Examples
Input
5 3 5 18 4
3 5 4
Output
4 1
Input
5 3 5 16 4
5 5 5
Output
-1
Note
The median of sequence a1, ..., an where n is odd (in this problem n is always odd) is the element staying on (n + 1) / 2 position in the sorted list of ai.
In the first sample the sum of marks equals 3 + 5 + 4 + 4 + 1 = 17, what doesn't exceed 18, that means that Vova won't be disturbed by his classmates. And the median point of the sequence {1, 3, 4, 4, 5} equals to 4, that isn't less than 4, so his mom lets him play computer games.
Please note that you do not have to maximize the sum of marks or the median mark. Any of the answers: "4 2", "2 4", "5 1", "1 5", "4 1", "1 4" for the first test is correct.
In the second sample Vova got three '5' marks, so even if he gets two '1' marks, the sum of marks will be 17, that is more than the required value of 16. So, the answer to this test is "-1".
Submitted Solution:
```
s=input().split()
n=int(s[0])
k=int(s[1])
p=int(s[2])
x=int(s[3])
y=int(s[4])
lst=input().split()
nl=0
nr=0
sl=0
sr=0
for v in lst:
if int(v)<y:
sl+=int(v)
nl+=1
else:
sr+=int(v)
nr+=1
listsum=sl+sr
if nr>=((n+1)//2):
l=n-(nr+nl)
if (l+listsum)>x:
print('-1')
else:
st=''
for v in range(l):
st=st +"1"+ " "
print(st)
else:
r=((n+1)//2) -nr
l=n-(nr+nl+r)
if (r*y +sr+sl+l)>x:
print('-1')
else:
st=""
for v in range(r):
st=st + "y"+ " "
for w in range(l):
st=st+ "1"+ " "
print(st)
``` | instruction | 0 | 61,871 | 17 | 123,742 |
No | output | 1 | 61,871 | 17 | 123,743 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n people taking part in auction today. The rules of auction are classical. There were n bids made, though it's not guaranteed they were from different people. It might happen that some people made no bids at all.
Each bid is define by two integers (ai, bi), where ai is the index of the person, who made this bid and bi is its size. Bids are given in chronological order, meaning bi < bi + 1 for all i < n. Moreover, participant never makes two bids in a row (no one updates his own bid), i.e. ai ≠ ai + 1 for all i < n.
Now you are curious with the following question: who (and which bid) will win the auction if some participants were absent? Consider that if someone was absent, all his bids are just removed and no new bids are added.
Note, that if during this imaginary exclusion of some participants it happens that some of the remaining participants makes a bid twice (or more times) in a row, only first of these bids is counted. For better understanding take a look at the samples.
You have several questions in your mind, compute the answer for each of them.
Input
The first line of the input contains an integer n (1 ≤ n ≤ 200 000) — the number of participants and bids.
Each of the following n lines contains two integers ai and bi (1 ≤ ai ≤ n, 1 ≤ bi ≤ 109, bi < bi + 1) — the number of participant who made the i-th bid and the size of this bid.
Next line contains an integer q (1 ≤ q ≤ 200 000) — the number of question you have in mind.
Each of next q lines contains an integer k (1 ≤ k ≤ n), followed by k integers lj (1 ≤ lj ≤ n) — the number of people who are not coming in this question and their indices. It is guarenteed that lj values are different for a single question.
It's guaranteed that the sum of k over all question won't exceed 200 000.
Output
For each question print two integer — the index of the winner and the size of the winning bid. If there is no winner (there are no remaining bids at all), print two zeroes.
Examples
Input
6
1 10
2 100
3 1000
1 10000
2 100000
3 1000000
3
1 3
2 2 3
2 1 2
Output
2 100000
1 10
3 1000
Input
3
1 10
2 100
1 1000
2
2 1 2
2 2 3
Output
0 0
1 10
Note
Consider the first sample:
* In the first question participant number 3 is absent so the sequence of bids looks as follows:
1. 1 10
2. 2 100
3. 1 10 000
4. 2 100 000
Participant number 2 wins with the bid 100 000.
* In the second question participants 2 and 3 are absent, so the sequence of bids looks:
1. 1 10
2. 1 10 000
The winner is, of course, participant number 1 but the winning bid is 10 instead of 10 000 as no one will ever increase his own bid (in this problem).
* In the third question participants 1 and 2 are absent and the sequence is:
1. 3 1 000
2. 3 1 000 000
The winner is participant 3 with the bid 1 000. | instruction | 0 | 61,943 | 17 | 123,886 |
Tags: binary search, data structures
Correct Solution:
```
# ---------------------------iye ha aam zindegi---------------------------------------------
import math
import random
import heapq, bisect
import sys
from collections import deque, defaultdict
from fractions import Fraction
import sys
import threading
from collections import defaultdict
threading.stack_size(10**8)
mod = 10 ** 9 + 7
mod1 = 998244353
# ------------------------------warmup----------------------------
import os
import sys
from io import BytesIO, IOBase
sys.setrecursionlimit(300000)
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# -------------------game starts now----------------------------------------------------import math
class TreeNode:
def __init__(self, k, v):
self.key = k
self.value = v
self.left = None
self.right = None
self.parent = None
self.height = 1
self.num_left = 1
self.num_total = 1
class AvlTree:
def __init__(self):
self._tree = None
def add(self, k, v):
if not self._tree:
self._tree = TreeNode(k, v)
return
node = self._add(k, v)
if node:
self._rebalance(node)
def _add(self, k, v):
node = self._tree
while node:
if k < node.key:
if node.left:
node = node.left
else:
node.left = TreeNode(k, v)
node.left.parent = node
return node.left
elif node.key < k:
if node.right:
node = node.right
else:
node.right = TreeNode(k, v)
node.right.parent = node
return node.right
else:
node.value = v
return
@staticmethod
def get_height(x):
return x.height if x else 0
@staticmethod
def get_num_total(x):
return x.num_total if x else 0
def _rebalance(self, node):
n = node
while n:
lh = self.get_height(n.left)
rh = self.get_height(n.right)
n.height = max(lh, rh) + 1
balance_factor = lh - rh
n.num_total = 1 + self.get_num_total(n.left) + self.get_num_total(n.right)
n.num_left = 1 + self.get_num_total(n.left)
if balance_factor > 1:
if self.get_height(n.left.left) < self.get_height(n.left.right):
self._rotate_left(n.left)
self._rotate_right(n)
elif balance_factor < -1:
if self.get_height(n.right.right) < self.get_height(n.right.left):
self._rotate_right(n.right)
self._rotate_left(n)
else:
n = n.parent
def _remove_one(self, node):
"""
Side effect!!! Changes node. Node should have exactly one child
"""
replacement = node.left or node.right
if node.parent:
if AvlTree._is_left(node):
node.parent.left = replacement
else:
node.parent.right = replacement
replacement.parent = node.parent
node.parent = None
else:
self._tree = replacement
replacement.parent = None
node.left = None
node.right = None
node.parent = None
self._rebalance(replacement)
def _remove_leaf(self, node):
if node.parent:
if AvlTree._is_left(node):
node.parent.left = None
else:
node.parent.right = None
self._rebalance(node.parent)
else:
self._tree = None
node.parent = None
node.left = None
node.right = None
def remove(self, k):
node = self._get_node(k)
if not node:
return
if AvlTree._is_leaf(node):
self._remove_leaf(node)
return
if node.left and node.right:
nxt = AvlTree._get_next(node)
node.key = nxt.key
node.value = nxt.value
if self._is_leaf(nxt):
self._remove_leaf(nxt)
else:
self._remove_one(nxt)
self._rebalance(node)
else:
self._remove_one(node)
def get(self, k):
node = self._get_node(k)
return node.value if node else -1
def _get_node(self, k):
if not self._tree:
return None
node = self._tree
while node:
if k < node.key:
node = node.left
elif node.key < k:
node = node.right
else:
return node
return None
def get_at(self, pos):
x = pos + 1
node = self._tree
while node:
if x < node.num_left:
node = node.left
elif node.num_left < x:
x -= node.num_left
node = node.right
else:
return (node.key, node.value)
raise IndexError("Out of ranges")
@staticmethod
def _is_left(node):
return node.parent.left and node.parent.left == node
@staticmethod
def _is_leaf(node):
return node.left is None and node.right is None
def _rotate_right(self, node):
if not node.parent:
self._tree = node.left
node.left.parent = None
elif AvlTree._is_left(node):
node.parent.left = node.left
node.left.parent = node.parent
else:
node.parent.right = node.left
node.left.parent = node.parent
bk = node.left.right
node.left.right = node
node.parent = node.left
node.left = bk
if bk:
bk.parent = node
node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
node.num_left = 1 + self.get_num_total(node.left)
def _rotate_left(self, node):
if not node.parent:
self._tree = node.right
node.right.parent = None
elif AvlTree._is_left(node):
node.parent.left = node.right
node.right.parent = node.parent
else:
node.parent.right = node.right
node.right.parent = node.parent
bk = node.right.left
node.right.left = node
node.parent = node.right
node.right = bk
if bk:
bk.parent = node
node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
node.num_left = 1 + self.get_num_total(node.left)
@staticmethod
def _get_next(node):
if not node.right:
return node.parent
n = node.right
while n.left:
n = n.left
return n
# -----------------------------------------------binary seacrh tree---------------------------------------
class SegmentTree1:
def __init__(self, data, default=2**51, func=lambda a, b: a & b):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
# -------------------game starts now----------------------------------------------------import math
class SegmentTree:
def __init__(self, data, default=-1, func=lambda a, b: max(a , b)):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
# -------------------------------iye ha chutiya zindegi-------------------------------------
class Factorial:
def __init__(self, MOD):
self.MOD = MOD
self.factorials = [1, 1]
self.invModulos = [0, 1]
self.invFactorial_ = [1, 1]
def calc(self, n):
if n <= -1:
print("Invalid argument to calculate n!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.factorials):
return self.factorials[n]
nextArr = [0] * (n + 1 - len(self.factorials))
initialI = len(self.factorials)
prev = self.factorials[-1]
m = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = prev * i % m
self.factorials += nextArr
return self.factorials[n]
def inv(self, n):
if n <= -1:
print("Invalid argument to calculate n^(-1)")
print("n must be non-negative value. But the argument was " + str(n))
exit()
p = self.MOD
pi = n % p
if pi < len(self.invModulos):
return self.invModulos[pi]
nextArr = [0] * (n + 1 - len(self.invModulos))
initialI = len(self.invModulos)
for i in range(initialI, min(p, n + 1)):
next = -self.invModulos[p % i] * (p // i) % p
self.invModulos.append(next)
return self.invModulos[pi]
def invFactorial(self, n):
if n <= -1:
print("Invalid argument to calculate (n^(-1))!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.invFactorial_):
return self.invFactorial_[n]
self.inv(n) # To make sure already calculated n^-1
nextArr = [0] * (n + 1 - len(self.invFactorial_))
initialI = len(self.invFactorial_)
prev = self.invFactorial_[-1]
p = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = (prev * self.invModulos[i % p]) % p
self.invFactorial_ += nextArr
return self.invFactorial_[n]
class Combination:
def __init__(self, MOD):
self.MOD = MOD
self.factorial = Factorial(MOD)
def ncr(self, n, k):
if k < 0 or n < k:
return 0
k = min(k, n - k)
f = self.factorial
return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD
# --------------------------------------iye ha combinations ka zindegi---------------------------------
def powm(a, n, m):
if a == 1 or n == 0:
return 1
if n % 2 == 0:
s = powm(a, n // 2, m)
return s * s % m
else:
return a * powm(a, n - 1, m) % m
# --------------------------------------iye ha power ka zindegi---------------------------------
def sort_list(list1, list2):
zipped_pairs = zip(list2, list1)
z = [x for _, x in sorted(zipped_pairs)]
return z
# --------------------------------------------------product----------------------------------------
def product(l):
por = 1
for i in range(len(l)):
por *= l[i]
return por
# --------------------------------------------------binary----------------------------------------
def binarySearchCount(arr, n, key):
left = 0
right = n - 1
count = 0
while (left <= right):
mid = int((right + left) / 2)
# Check if middle element is
# less than or equal to key
if (arr[mid] < key):
count = mid + 1
left = mid + 1
# If key is smaller, ignore right half
else:
right = mid - 1
return count
# --------------------------------------------------binary----------------------------------------
def countdig(n):
c = 0
while (n > 0):
n //= 10
c += 1
return c
def binary(x, length):
y = bin(x)[2:]
return y if len(y) >= length else "0" * (length - len(y)) + y
def countGreater(arr, n, k):
l = 0
r = n - 1
# Stores the index of the left most element
# from the array which is greater than k
leftGreater = n
# Finds number of elements greater than k
while (l <= r):
m = int(l + (r - l) / 2)
if (arr[m] >= k):
leftGreater = m
r = m - 1
# If mid element is less than
# or equal to k update l
else:
l = m + 1
# Return the count of elements
# greater than k
return (n - leftGreater)
# --------------------------------------------------binary------------------------------------
n=int(input())
w=defaultdict(int)
d=defaultdict(list)
cost=[0]*n
ma=[-1]*(n+1)
for i in range(n):
a,b=map(int,input().split())
d[a].append(i)
w[i]=a
cost[i]=b
for i in d:
ma[i]=d[i][-1]
s=SegmentTree(ma)
q=int(input())
for i in range(q):
l=list(map(int,input().split()))
k=l[0]
l=l[1:]
l.append(n+1)
l.sort()
m=-1
last=0
for j in range(k+1):
m=max(m,s.query(last,l[j]-1))
last=l[j]+1
if m==-1:
print(0,0)
continue
ind=w[m]
l.append(ind)
l.sort()
m1=-1
last=0
for j in range(k+2):
m1 = max(m1, s.query(last, l[j] - 1))
last = l[j] + 1
x=binarySearchCount(d[ind],len(d[ind]),m1)
print(ind,cost[d[ind][x]])
``` | output | 1 | 61,943 | 17 | 123,887 |
Provide a correct Python 3 solution for this coding contest problem.
A programming contest is held every year at White Tiger University. When the total number of teams is N, each team is assigned a team ID from 1 to N. The contest starts with all teams scoring 0 and runs continuously for L seconds.
This year's contest will be broadcast on TV. Only the team with the highest score at the time will be shown on TV during the contest. However, if there are multiple applicable teams, the team with the smallest team ID will be displayed. When the team to be projected changes, the camera changes instantly.
You got the contest log. The log contains all the records when a team's score changed. Each record is given in the form of "Team d scored x points t seconds after the start of the contest". The current score may be less than 0 because points may be deducted.
Create a program that takes the contest log as input and reports the ID of the team that has been on TV for the longest time between the start and end of the contest.
input
The input consists of one dataset. The input is given in the following format.
N R L
d1 t1 x1
d2 t2 x2
::
dR tR xR
The first line consists of three integers. N (2 ≤ N ≤ 100000) is the number of teams and R (0 ≤ R ≤ 1000000) is the number of records in the log. L (1 ≤ L ≤ 1000000) represents the time (length) of the contest. The information of each record is given in the following R line. Each record shows that team di (1 ≤ di ≤ N) has scored or deducted xi (-1000 ≤ xi ≤ 1000) points ti (0 <ti <L) seconds after the start of the contest. However, ti and xi are integers, and ti-1 ≤ ti.
output
The ID of the team that has been shown on TV for the longest time between the start and end of the contest is output on one line. However, if there are multiple teams with the longest length, the team with the smallest team ID is output.
Example
Input
3 4 600
3 100 5
1 200 10
2 400 20
3 500 20
Output
1 | instruction | 0 | 62,201 | 17 | 124,402 |
"Correct Solution:
```
# -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0282
"""
import sys
from sys import stdin
from heapq import heappop, heappush
input = stdin.readline
pq = [] # list of entries arranged in a heap
entry_finder = {} # mapping of tasks to entries
REMOVED = float('inf') # placeholder for a removed task
def add_team(score, team):
if team in entry_finder:
remove_team(team)
entry = [-score, team]
entry_finder[team] = entry
heappush(pq, entry)
def remove_team(team):
entry = entry_finder.pop(team)
entry[-1] = REMOVED
def pop_team():
while pq:
score, team = heappop(pq)
if team is not REMOVED:
del entry_finder[team]
return score, team
raise KeyError('pop from an empty priority queue')
def main(args):
N, R, L = map(int, input().split(' '))
on_tv = [0] * (N + 1) # ????????????????????¬???????????£??????????????????????¨?
scores = [0] * (N + 1) # ????????????????????¨?????????
#for i in range(1, N+1):
# add_team(0, i)
add_team(0, 1)
last_time = 0
need_pop = True
top_score = 0
for i in range(R):
d, t, x = [int(x) for x in input().split(' ')]
if need_pop:
need_pop = False
top_score, team = pop_team()
if d != team:
add_team(scores[team], team)
on_tv[team] += (t - last_time)
scores[d] += x
add_team(scores[d], d)
if x > 0 and scores[d] > top_score:
need_pop = True
last_time = t
t = L
score, team = pop_team()
on_tv[team] += (t - last_time)
print(on_tv.index(max(on_tv)))
if __name__ == '__main__':
main(sys.argv[1:])
``` | output | 1 | 62,201 | 17 | 124,403 |
Provide a correct Python 3 solution for this coding contest problem.
A programming contest is held every year at White Tiger University. When the total number of teams is N, each team is assigned a team ID from 1 to N. The contest starts with all teams scoring 0 and runs continuously for L seconds.
This year's contest will be broadcast on TV. Only the team with the highest score at the time will be shown on TV during the contest. However, if there are multiple applicable teams, the team with the smallest team ID will be displayed. When the team to be projected changes, the camera changes instantly.
You got the contest log. The log contains all the records when a team's score changed. Each record is given in the form of "Team d scored x points t seconds after the start of the contest". The current score may be less than 0 because points may be deducted.
Create a program that takes the contest log as input and reports the ID of the team that has been on TV for the longest time between the start and end of the contest.
input
The input consists of one dataset. The input is given in the following format.
N R L
d1 t1 x1
d2 t2 x2
::
dR tR xR
The first line consists of three integers. N (2 ≤ N ≤ 100000) is the number of teams and R (0 ≤ R ≤ 1000000) is the number of records in the log. L (1 ≤ L ≤ 1000000) represents the time (length) of the contest. The information of each record is given in the following R line. Each record shows that team di (1 ≤ di ≤ N) has scored or deducted xi (-1000 ≤ xi ≤ 1000) points ti (0 <ti <L) seconds after the start of the contest. However, ti and xi are integers, and ti-1 ≤ ti.
output
The ID of the team that has been shown on TV for the longest time between the start and end of the contest is output on one line. However, if there are multiple teams with the longest length, the team with the smallest team ID is output.
Example
Input
3 4 600
3 100 5
1 200 10
2 400 20
3 500 20
Output
1 | instruction | 0 | 62,202 | 17 | 124,404 |
"Correct Solution:
```
import sys
f = sys.stdin
n, r, l = map(int, f.readline().split())
appearance = [0] * n
point = [0] * n
top = 0
pre_t = 0
for line in f:
d, t, x = map(int, line.split())
d -= 1 # 0-index?????????
appearance[top] += t - pre_t
pre_t = t
point[d] += x
if 0 < x and top != d:
if point[top] < point[d]:
top = d
elif point[top] == point[d] and d < top:
top = d
elif x < 0 and top == d:
top = point.index(max(point))
appearance[top] += l - pre_t
print(1 + appearance.index(max(appearance)))
``` | output | 1 | 62,202 | 17 | 124,405 |
Provide a correct Python 3 solution for this coding contest problem.
A programming contest is held every year at White Tiger University. When the total number of teams is N, each team is assigned a team ID from 1 to N. The contest starts with all teams scoring 0 and runs continuously for L seconds.
This year's contest will be broadcast on TV. Only the team with the highest score at the time will be shown on TV during the contest. However, if there are multiple applicable teams, the team with the smallest team ID will be displayed. When the team to be projected changes, the camera changes instantly.
You got the contest log. The log contains all the records when a team's score changed. Each record is given in the form of "Team d scored x points t seconds after the start of the contest". The current score may be less than 0 because points may be deducted.
Create a program that takes the contest log as input and reports the ID of the team that has been on TV for the longest time between the start and end of the contest.
input
The input consists of one dataset. The input is given in the following format.
N R L
d1 t1 x1
d2 t2 x2
::
dR tR xR
The first line consists of three integers. N (2 ≤ N ≤ 100000) is the number of teams and R (0 ≤ R ≤ 1000000) is the number of records in the log. L (1 ≤ L ≤ 1000000) represents the time (length) of the contest. The information of each record is given in the following R line. Each record shows that team di (1 ≤ di ≤ N) has scored or deducted xi (-1000 ≤ xi ≤ 1000) points ti (0 <ti <L) seconds after the start of the contest. However, ti and xi are integers, and ti-1 ≤ ti.
output
The ID of the team that has been shown on TV for the longest time between the start and end of the contest is output on one line. However, if there are multiple teams with the longest length, the team with the smallest team ID is output.
Example
Input
3 4 600
3 100 5
1 200 10
2 400 20
3 500 20
Output
1 | instruction | 0 | 62,203 | 17 | 124,406 |
"Correct Solution:
```
import sys
input = sys.stdin.readline
from heapq import *
N, R, L = map(int, input().split())
score = [0]*N
pq = []
for i in range(N):
heappush(pq, (-score[i], i))
prev_t = 0
now = 0
time = [0]*N
for _ in range(R):
di, ti, xi = map(int, input().split())
time[now] += ti-prev_t
prev_t = ti
heappush(pq, (-score[now], now))
heappush(pq, (-score[di-1]-xi, di-1))
score[di-1] += xi
while True:
s, idx = heappop(pq)
s *= -1
if score[idx]==s:
break
now = idx
time[now] += L-prev_t
max_t = 0
ans = -1
for i in range(N):
if time[i]>max_t:
max_t = time[i]
ans = i+1
print(ans)
``` | output | 1 | 62,203 | 17 | 124,407 |
Provide a correct Python 3 solution for this coding contest problem.
A programming contest is held every year at White Tiger University. When the total number of teams is N, each team is assigned a team ID from 1 to N. The contest starts with all teams scoring 0 and runs continuously for L seconds.
This year's contest will be broadcast on TV. Only the team with the highest score at the time will be shown on TV during the contest. However, if there are multiple applicable teams, the team with the smallest team ID will be displayed. When the team to be projected changes, the camera changes instantly.
You got the contest log. The log contains all the records when a team's score changed. Each record is given in the form of "Team d scored x points t seconds after the start of the contest". The current score may be less than 0 because points may be deducted.
Create a program that takes the contest log as input and reports the ID of the team that has been on TV for the longest time between the start and end of the contest.
input
The input consists of one dataset. The input is given in the following format.
N R L
d1 t1 x1
d2 t2 x2
::
dR tR xR
The first line consists of three integers. N (2 ≤ N ≤ 100000) is the number of teams and R (0 ≤ R ≤ 1000000) is the number of records in the log. L (1 ≤ L ≤ 1000000) represents the time (length) of the contest. The information of each record is given in the following R line. Each record shows that team di (1 ≤ di ≤ N) has scored or deducted xi (-1000 ≤ xi ≤ 1000) points ti (0 <ti <L) seconds after the start of the contest. However, ti and xi are integers, and ti-1 ≤ ti.
output
The ID of the team that has been shown on TV for the longest time between the start and end of the contest is output on one line. However, if there are multiple teams with the longest length, the team with the smallest team ID is output.
Example
Input
3 4 600
3 100 5
1 200 10
2 400 20
3 500 20
Output
1 | instruction | 0 | 62,204 | 17 | 124,408 |
"Correct Solution:
```
import sys
from heapq import heappush, heappop, heapreplace
def solve():
file_input = sys.stdin
N, R, L = map(int, file_input.readline().split())
pq = [[0, i] for i in range(1, N + 1)]
m = dict(zip(range(1, N + 1), pq))
time = [0] * (N + 1)
INVALID = -1
pre_t = 0
for line in file_input:
d, t, x = map(int, line.split())
top_team = pq[0]
time[top_team[1]] += t - pre_t
pre_t = t
if top_team[1] == d:
top_team[0] -= x
if x < 0:
heapreplace(pq, top_team)
else:
scored_team = m[d][:]
scored_team[0] -= x
heappush(pq, scored_team)
m[d][1] = INVALID
m[d] = scored_team
while pq[0][1] == INVALID:
heappop(pq)
time[pq[0][1]] += L - pre_t
print(time.index(max(time)))
solve()
``` | output | 1 | 62,204 | 17 | 124,409 |
Provide a correct Python 3 solution for this coding contest problem.
A programming contest is held every year at White Tiger University. When the total number of teams is N, each team is assigned a team ID from 1 to N. The contest starts with all teams scoring 0 and runs continuously for L seconds.
This year's contest will be broadcast on TV. Only the team with the highest score at the time will be shown on TV during the contest. However, if there are multiple applicable teams, the team with the smallest team ID will be displayed. When the team to be projected changes, the camera changes instantly.
You got the contest log. The log contains all the records when a team's score changed. Each record is given in the form of "Team d scored x points t seconds after the start of the contest". The current score may be less than 0 because points may be deducted.
Create a program that takes the contest log as input and reports the ID of the team that has been on TV for the longest time between the start and end of the contest.
input
The input consists of one dataset. The input is given in the following format.
N R L
d1 t1 x1
d2 t2 x2
::
dR tR xR
The first line consists of three integers. N (2 ≤ N ≤ 100000) is the number of teams and R (0 ≤ R ≤ 1000000) is the number of records in the log. L (1 ≤ L ≤ 1000000) represents the time (length) of the contest. The information of each record is given in the following R line. Each record shows that team di (1 ≤ di ≤ N) has scored or deducted xi (-1000 ≤ xi ≤ 1000) points ti (0 <ti <L) seconds after the start of the contest. However, ti and xi are integers, and ti-1 ≤ ti.
output
The ID of the team that has been shown on TV for the longest time between the start and end of the contest is output on one line. However, if there are multiple teams with the longest length, the team with the smallest team ID is output.
Example
Input
3 4 600
3 100 5
1 200 10
2 400 20
3 500 20
Output
1 | instruction | 0 | 62,205 | 17 | 124,410 |
"Correct Solution:
```
import sys
from heapq import heappush, heappop
def solve():
file_input = sys.stdin
N, R, L = map(int, file_input.readline().split())
hq = []
m = {}
for i in range(1, N + 1):
team = [0, i, 0]
heappush(hq, team)
m[i] = team
time = 0
for line in file_input:
d, t, x = map(int, line.split())
hq[0][2] += t - time
time = t
scored_team = m[d][:]
scored_team[0] -= x
heappush(hq, scored_team)
m[d][2] = -1
m[d] = scored_team
while hq[0][2] == -1:
heappop(hq)
hq[0][2] += L - time
ans_team = max(hq, key = lambda x: (x[2], -x[1]))
print(ans_team[1])
solve()
``` | output | 1 | 62,205 | 17 | 124,411 |
Provide a correct Python 3 solution for this coding contest problem.
A programming contest is held every year at White Tiger University. When the total number of teams is N, each team is assigned a team ID from 1 to N. The contest starts with all teams scoring 0 and runs continuously for L seconds.
This year's contest will be broadcast on TV. Only the team with the highest score at the time will be shown on TV during the contest. However, if there are multiple applicable teams, the team with the smallest team ID will be displayed. When the team to be projected changes, the camera changes instantly.
You got the contest log. The log contains all the records when a team's score changed. Each record is given in the form of "Team d scored x points t seconds after the start of the contest". The current score may be less than 0 because points may be deducted.
Create a program that takes the contest log as input and reports the ID of the team that has been on TV for the longest time between the start and end of the contest.
input
The input consists of one dataset. The input is given in the following format.
N R L
d1 t1 x1
d2 t2 x2
::
dR tR xR
The first line consists of three integers. N (2 ≤ N ≤ 100000) is the number of teams and R (0 ≤ R ≤ 1000000) is the number of records in the log. L (1 ≤ L ≤ 1000000) represents the time (length) of the contest. The information of each record is given in the following R line. Each record shows that team di (1 ≤ di ≤ N) has scored or deducted xi (-1000 ≤ xi ≤ 1000) points ti (0 <ti <L) seconds after the start of the contest. However, ti and xi are integers, and ti-1 ≤ ti.
output
The ID of the team that has been shown on TV for the longest time between the start and end of the contest is output on one line. However, if there are multiple teams with the longest length, the team with the smallest team ID is output.
Example
Input
3 4 600
3 100 5
1 200 10
2 400 20
3 500 20
Output
1 | instruction | 0 | 62,206 | 17 | 124,412 |
"Correct Solution:
```
import sys
from heapq import heappush, heappop, heapreplace
def solve():
file_input = sys.stdin
N, R, L = map(int, file_input.readline().split())
pq = [[0, i, 0] for i in range(1, N + 1)]
m = dict(zip(range(1, N + 1), pq))
pre_t = 0
for line in file_input:
d, t, x = map(int, line.split())
team = pq[0]
team[2] += t - pre_t
pre_t = t
if team[1] == d:
team[0] -= x
if x < 0:
heapreplace(pq, team)
else:
scored_team = m[d][:]
scored_team[0] -= x
heappush(pq, scored_team)
m[d][2] = -1
m[d] = scored_team
while pq[0][2] == -1:
heappop(pq)
pq[0][2] += L - pre_t
ans_team = max(pq, key = lambda x: (x[2], -x[1]))
print(ans_team[1])
solve()
``` | output | 1 | 62,206 | 17 | 124,413 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A programming contest is held every year at White Tiger University. When the total number of teams is N, each team is assigned a team ID from 1 to N. The contest starts with all teams scoring 0 and runs continuously for L seconds.
This year's contest will be broadcast on TV. Only the team with the highest score at the time will be shown on TV during the contest. However, if there are multiple applicable teams, the team with the smallest team ID will be displayed. When the team to be projected changes, the camera changes instantly.
You got the contest log. The log contains all the records when a team's score changed. Each record is given in the form of "Team d scored x points t seconds after the start of the contest". The current score may be less than 0 because points may be deducted.
Create a program that takes the contest log as input and reports the ID of the team that has been on TV for the longest time between the start and end of the contest.
input
The input consists of one dataset. The input is given in the following format.
N R L
d1 t1 x1
d2 t2 x2
::
dR tR xR
The first line consists of three integers. N (2 ≤ N ≤ 100000) is the number of teams and R (0 ≤ R ≤ 1000000) is the number of records in the log. L (1 ≤ L ≤ 1000000) represents the time (length) of the contest. The information of each record is given in the following R line. Each record shows that team di (1 ≤ di ≤ N) has scored or deducted xi (-1000 ≤ xi ≤ 1000) points ti (0 <ti <L) seconds after the start of the contest. However, ti and xi are integers, and ti-1 ≤ ti.
output
The ID of the team that has been shown on TV for the longest time between the start and end of the contest is output on one line. However, if there are multiple teams with the longest length, the team with the smallest team ID is output.
Example
Input
3 4 600
3 100 5
1 200 10
2 400 20
3 500 20
Output
1
Submitted Solution:
```
N, R, L = list(map(int, input().split(" ")))
i = 1
while i<N*2:
i<<=1
tree = [0 for j in range(i)]
time = [0 for j in range(N)]
tree[0] = -1
def foo(a,x):
def bar(k,a,x,l,r):
mid = (l+r)//2
if r-l == 1:
tree[k] += x
tree[0] = l
return(tree[k])
elif a<mid:
tree[k] = max(bar(k*2,a,x,l,mid), tree[k])
return(tree[k])
else:
tree[k] = max(bar(k*2+1,a,x,mid,r), tree[k])
return(tree[k])
bar(1,a,x,0,i//2)
return(tree[1],tree[0])
nowtime = 0
nowmax = 0
nowpoint = 0
for j in range(R):
d,t,x = map(int, input().split(" "))
d -= 1
time[nowmax] += t-nowtime
nowtime = t
newpoint, newmax = foo(d,x)
if nowpoint < newpoint:
nowmax = newmax
nowpoint = newpoint
elif nowpoint == newpoint:
nowmax = min(nowmax, newmax)
time[nowmax] += L-nowtime
print(time.index(max(time))+1)
``` | instruction | 0 | 62,207 | 17 | 124,414 |
No | output | 1 | 62,207 | 17 | 124,415 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A programming contest is held every year at White Tiger University. When the total number of teams is N, each team is assigned a team ID from 1 to N. The contest starts with all teams scoring 0 and runs continuously for L seconds.
This year's contest will be broadcast on TV. Only the team with the highest score at the time will be shown on TV during the contest. However, if there are multiple applicable teams, the team with the smallest team ID will be displayed. When the team to be projected changes, the camera changes instantly.
You got the contest log. The log contains all the records when a team's score changed. Each record is given in the form of "Team d scored x points t seconds after the start of the contest". The current score may be less than 0 because points may be deducted.
Create a program that takes the contest log as input and reports the ID of the team that has been on TV for the longest time between the start and end of the contest.
input
The input consists of one dataset. The input is given in the following format.
N R L
d1 t1 x1
d2 t2 x2
::
dR tR xR
The first line consists of three integers. N (2 ≤ N ≤ 100000) is the number of teams and R (0 ≤ R ≤ 1000000) is the number of records in the log. L (1 ≤ L ≤ 1000000) represents the time (length) of the contest. The information of each record is given in the following R line. Each record shows that team di (1 ≤ di ≤ N) has scored or deducted xi (-1000 ≤ xi ≤ 1000) points ti (0 <ti <L) seconds after the start of the contest. However, ti and xi are integers, and ti-1 ≤ ti.
output
The ID of the team that has been shown on TV for the longest time between the start and end of the contest is output on one line. However, if there are multiple teams with the longest length, the team with the smallest team ID is output.
Example
Input
3 4 600
3 100 5
1 200 10
2 400 20
3 500 20
Output
1
Submitted Solution:
```
n, r, l = map(int, input().split())
p = [0 for i in range(n + 1)] #得点
p[0] = -10e10
t = [0 for i in range(n + 1)] #時間
now = [1, 0]
for _ in range(r):
re = list(map(int, input().split()))
t[now[0]] += re[1] - now[1]
p[re[0]] += re[2]
now[1] = re[1]
now[0] = p.index(max(p))
t[now[0]] += l - now[1]
print(t.index(max(t)))
``` | instruction | 0 | 62,208 | 17 | 124,416 |
No | output | 1 | 62,208 | 17 | 124,417 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A programming contest is held every year at White Tiger University. When the total number of teams is N, each team is assigned a team ID from 1 to N. The contest starts with all teams scoring 0 and runs continuously for L seconds.
This year's contest will be broadcast on TV. Only the team with the highest score at the time will be shown on TV during the contest. However, if there are multiple applicable teams, the team with the smallest team ID will be displayed. When the team to be projected changes, the camera changes instantly.
You got the contest log. The log contains all the records when a team's score changed. Each record is given in the form of "Team d scored x points t seconds after the start of the contest". The current score may be less than 0 because points may be deducted.
Create a program that takes the contest log as input and reports the ID of the team that has been on TV for the longest time between the start and end of the contest.
input
The input consists of one dataset. The input is given in the following format.
N R L
d1 t1 x1
d2 t2 x2
::
dR tR xR
The first line consists of three integers. N (2 ≤ N ≤ 100000) is the number of teams and R (0 ≤ R ≤ 1000000) is the number of records in the log. L (1 ≤ L ≤ 1000000) represents the time (length) of the contest. The information of each record is given in the following R line. Each record shows that team di (1 ≤ di ≤ N) has scored or deducted xi (-1000 ≤ xi ≤ 1000) points ti (0 <ti <L) seconds after the start of the contest. However, ti and xi are integers, and ti-1 ≤ ti.
output
The ID of the team that has been shown on TV for the longest time between the start and end of the contest is output on one line. However, if there are multiple teams with the longest length, the team with the smallest team ID is output.
Example
Input
3 4 600
3 100 5
1 200 10
2 400 20
3 500 20
Output
1
Submitted Solution:
```
# -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0282
"""
import sys
from sys import stdin
from heapq import heappop, heappush
input = stdin.readline
pq = [] # list of entries arranged in a heap
entry_finder = {} # mapping of tasks to entries
REMOVED = 100000000 # placeholder for a removed task
def add_team(score, team):
if team in entry_finder:
remove_team(team)
entry = [-score, team]
entry_finder[team] = entry
heappush(pq, entry)
def remove_team(team):
entry = entry_finder.pop(team)
entry[-1] = REMOVED
def pop_team():
while pq:
score, team = heappop(pq)
if team is not REMOVED:
del entry_finder[team]
return team
raise KeyError('pop from an empty priority queue')
def main(args):
N, R, L = map(int, input().split())
on_tv = [0] * (N + 1) # ????????????????????¬???????????£??????????????????????¨?
scores = [0] * (N + 1) # ????????????????????¨?????????
for i in range(1, N+1):
add_team(0, i)
last_time = 0
for i in range(R):
d, t, x = [int(x) for x in input().split()]
team = pop_team()
on_tv[team] += (t - last_time)
if d != team:
add_team(scores[team], team)
scores[d] += x
add_team(scores[d], d)
last_time = t
t = L
team = pop_team()
on_tv[team] += (t - last_time)
print(on_tv.index(max(on_tv)))
if __name__ == '__main__':
main(sys.argv[1:])
``` | instruction | 0 | 62,209 | 17 | 124,418 |
No | output | 1 | 62,209 | 17 | 124,419 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A programming contest is held every year at White Tiger University. When the total number of teams is N, each team is assigned a team ID from 1 to N. The contest starts with all teams scoring 0 and runs continuously for L seconds.
This year's contest will be broadcast on TV. Only the team with the highest score at the time will be shown on TV during the contest. However, if there are multiple applicable teams, the team with the smallest team ID will be displayed. When the team to be projected changes, the camera changes instantly.
You got the contest log. The log contains all the records when a team's score changed. Each record is given in the form of "Team d scored x points t seconds after the start of the contest". The current score may be less than 0 because points may be deducted.
Create a program that takes the contest log as input and reports the ID of the team that has been on TV for the longest time between the start and end of the contest.
input
The input consists of one dataset. The input is given in the following format.
N R L
d1 t1 x1
d2 t2 x2
::
dR tR xR
The first line consists of three integers. N (2 ≤ N ≤ 100000) is the number of teams and R (0 ≤ R ≤ 1000000) is the number of records in the log. L (1 ≤ L ≤ 1000000) represents the time (length) of the contest. The information of each record is given in the following R line. Each record shows that team di (1 ≤ di ≤ N) has scored or deducted xi (-1000 ≤ xi ≤ 1000) points ti (0 <ti <L) seconds after the start of the contest. However, ti and xi are integers, and ti-1 ≤ ti.
output
The ID of the team that has been shown on TV for the longest time between the start and end of the contest is output on one line. However, if there are multiple teams with the longest length, the team with the smallest team ID is output.
Example
Input
3 4 600
3 100 5
1 200 10
2 400 20
3 500 20
Output
1
Submitted Solution:
```
# -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0282
"""
import sys
from sys import stdin
input = stdin.readline
class RMQ(object):
INT_MAX = 2**31 - 1
def __init__(self, nn, init_val=0):
self.n = 1
while self.n < nn:
self.n *= 2
self.dat = [init_val] * ((2 * self.n)-1)
def update(self, k, a):
# A[k]???a?????´??°?????????????????°???????????¨?????´??°
k += (self.n - 1)
self.dat[k] = a
while k > 0:
k = (k - 1) // 2 # ??????index??????
self.dat[k] = min(self.dat[k * 2 + 1], self.dat[k * 2 + 2]) # ???????????¨??????????????????????°?????????????????????´??°
def query(self, a, b, k, l, r):
# [a, b)???????°????????±??????? (0????????§b???????????????)
# ??????????????¨?????????query(a, b, 0, 0, n)?????¢??§??????????????????k, l, r???????????????????????´??°?????????
if r <= a or b <= l: # ?????????????????§??¨??????????????????
return RMQ.INT_MAX
if a <=l and r <= b:
return self.dat[k] # ???????????°???????????????????????§????????°????????¨??????????????????????°?????????????????????????
else:
vl = self.query(a, b, k*2+1, l, (l+r)//2) # ????????°????????????????°????
vr = self.query(a, b, k*2+2, (l+r)//2, r) # ????????°????????????????°????
return min(vl, vr)
def find(self, s, t):
return self.query(s, t+1, 0, 0, self.n)
def main(args):
N, R, L = map(int, input().split(' '))
on_tv = [0] * (N + 1) # ????????????????????¬???????????£??????????????????????¨?
scores = [0] * (N + 1) # ????????????????????¨?????????
scores[0] = float('-inf')
rq = RMQ(N+1)
last_time = 0
for i in range(R):
d, t, x = [int(x) for x in input().split(' ')]
top_score = rq.find(1, N)
top_team = scores.index(-top_score)
on_tv[top_team] += (t - last_time)
scores[d] += x
rq.update(d, -scores[d])
last_time = t
t = L
top_score = rq.find(1, N)
top_team = scores.index(-top_score)
on_tv[top_team] += (t - last_time)
print(on_tv.index(max(on_tv)))
if __name__ == '__main__':
main(sys.argv[1:])
``` | instruction | 0 | 62,210 | 17 | 124,420 |
No | output | 1 | 62,210 | 17 | 124,421 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In Berland each high school student is characterized by academic performance — integer value between 1 and 5.
In high school 0xFF there are two groups of pupils: the group A and the group B. Each group consists of exactly n students. An academic performance of each student is known — integer value between 1 and 5.
The school director wants to redistribute students between groups so that each of the two groups has the same number of students whose academic performance is equal to 1, the same number of students whose academic performance is 2 and so on. In other words, the purpose of the school director is to change the composition of groups, so that for each value of academic performance the numbers of students in both groups are equal.
To achieve this, there is a plan to produce a series of exchanges of students between groups. During the single exchange the director selects one student from the class A and one student of class B. After that, they both change their groups.
Print the least number of exchanges, in order to achieve the desired equal numbers of students for each academic performance.
Input
The first line of the input contains integer number n (1 ≤ n ≤ 100) — number of students in both groups.
The second line contains sequence of integer numbers a1, a2, ..., an (1 ≤ ai ≤ 5), where ai is academic performance of the i-th student of the group A.
The third line contains sequence of integer numbers b1, b2, ..., bn (1 ≤ bi ≤ 5), where bi is academic performance of the i-th student of the group B.
Output
Print the required minimum number of exchanges or -1, if the desired distribution of students can not be obtained.
Examples
Input
4
5 4 4 4
5 5 4 5
Output
1
Input
6
1 1 1 1 1 1
5 5 5 5 5 5
Output
3
Input
1
5
3
Output
-1
Input
9
3 2 5 5 2 3 3 3 2
4 1 4 1 1 2 4 4 1
Output
4 | instruction | 0 | 62,797 | 17 | 125,594 |
Tags: constructive algorithms, math
Correct Solution:
```
n=int(input())
a=list(map(int,input().split()))
b=list(map(int,input().split()))
s=0
for i in range(1,6):
x=a.count(i)
y=b.count(i)
if not (x+y)%2:s+=abs(x-y)//2
else:exit(print(-1))
print(s//2)
``` | output | 1 | 62,797 | 17 | 125,595 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In Berland each high school student is characterized by academic performance — integer value between 1 and 5.
In high school 0xFF there are two groups of pupils: the group A and the group B. Each group consists of exactly n students. An academic performance of each student is known — integer value between 1 and 5.
The school director wants to redistribute students between groups so that each of the two groups has the same number of students whose academic performance is equal to 1, the same number of students whose academic performance is 2 and so on. In other words, the purpose of the school director is to change the composition of groups, so that for each value of academic performance the numbers of students in both groups are equal.
To achieve this, there is a plan to produce a series of exchanges of students between groups. During the single exchange the director selects one student from the class A and one student of class B. After that, they both change their groups.
Print the least number of exchanges, in order to achieve the desired equal numbers of students for each academic performance.
Input
The first line of the input contains integer number n (1 ≤ n ≤ 100) — number of students in both groups.
The second line contains sequence of integer numbers a1, a2, ..., an (1 ≤ ai ≤ 5), where ai is academic performance of the i-th student of the group A.
The third line contains sequence of integer numbers b1, b2, ..., bn (1 ≤ bi ≤ 5), where bi is academic performance of the i-th student of the group B.
Output
Print the required minimum number of exchanges or -1, if the desired distribution of students can not be obtained.
Examples
Input
4
5 4 4 4
5 5 4 5
Output
1
Input
6
1 1 1 1 1 1
5 5 5 5 5 5
Output
3
Input
1
5
3
Output
-1
Input
9
3 2 5 5 2 3 3 3 2
4 1 4 1 1 2 4 4 1
Output
4 | instruction | 0 | 62,798 | 17 | 125,596 |
Tags: constructive algorithms, math
Correct Solution:
```
n = int(input())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
q = [0] * 6
for i in a:
q[i] += 1
for i in b:
q[i] += 1
f = True
for i in q:
if i % 2 != 0:
f = False
if not f:
print(-1)
else:
for i in range(6):
q[i] //= 2
aa = [0] * 6
bb = [0] * 6
for i in a:
aa[i] += 1
for i in b:
bb[i] += 1
ans = 0
for i in range(6):
ans += abs(q[i] - aa[i])
print(ans // 2)
``` | output | 1 | 62,798 | 17 | 125,597 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In Berland each high school student is characterized by academic performance — integer value between 1 and 5.
In high school 0xFF there are two groups of pupils: the group A and the group B. Each group consists of exactly n students. An academic performance of each student is known — integer value between 1 and 5.
The school director wants to redistribute students between groups so that each of the two groups has the same number of students whose academic performance is equal to 1, the same number of students whose academic performance is 2 and so on. In other words, the purpose of the school director is to change the composition of groups, so that for each value of academic performance the numbers of students in both groups are equal.
To achieve this, there is a plan to produce a series of exchanges of students between groups. During the single exchange the director selects one student from the class A and one student of class B. After that, they both change their groups.
Print the least number of exchanges, in order to achieve the desired equal numbers of students for each academic performance.
Input
The first line of the input contains integer number n (1 ≤ n ≤ 100) — number of students in both groups.
The second line contains sequence of integer numbers a1, a2, ..., an (1 ≤ ai ≤ 5), where ai is academic performance of the i-th student of the group A.
The third line contains sequence of integer numbers b1, b2, ..., bn (1 ≤ bi ≤ 5), where bi is academic performance of the i-th student of the group B.
Output
Print the required minimum number of exchanges or -1, if the desired distribution of students can not be obtained.
Examples
Input
4
5 4 4 4
5 5 4 5
Output
1
Input
6
1 1 1 1 1 1
5 5 5 5 5 5
Output
3
Input
1
5
3
Output
-1
Input
9
3 2 5 5 2 3 3 3 2
4 1 4 1 1 2 4 4 1
Output
4 | instruction | 0 | 62,799 | 17 | 125,598 |
Tags: constructive algorithms, math
Correct Solution:
```
#RAVENS
#TEAM_2
#ESSI-DAYI_MOHSEN-LORENZO
n = int(input())
a = list(map(int,input().split()))
b = list(map(int,input().split()))
cnt = [0]*6
for i in a:cnt[i]+=1
for i in b:cnt[i]-=1
su = 0
for i in cnt:
if i % 2 != 0:print(-1);exit()
if i > 0:su+=i
print(su//2)
``` | output | 1 | 62,799 | 17 | 125,599 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In Berland each high school student is characterized by academic performance — integer value between 1 and 5.
In high school 0xFF there are two groups of pupils: the group A and the group B. Each group consists of exactly n students. An academic performance of each student is known — integer value between 1 and 5.
The school director wants to redistribute students between groups so that each of the two groups has the same number of students whose academic performance is equal to 1, the same number of students whose academic performance is 2 and so on. In other words, the purpose of the school director is to change the composition of groups, so that for each value of academic performance the numbers of students in both groups are equal.
To achieve this, there is a plan to produce a series of exchanges of students between groups. During the single exchange the director selects one student from the class A and one student of class B. After that, they both change their groups.
Print the least number of exchanges, in order to achieve the desired equal numbers of students for each academic performance.
Input
The first line of the input contains integer number n (1 ≤ n ≤ 100) — number of students in both groups.
The second line contains sequence of integer numbers a1, a2, ..., an (1 ≤ ai ≤ 5), where ai is academic performance of the i-th student of the group A.
The third line contains sequence of integer numbers b1, b2, ..., bn (1 ≤ bi ≤ 5), where bi is academic performance of the i-th student of the group B.
Output
Print the required minimum number of exchanges or -1, if the desired distribution of students can not be obtained.
Examples
Input
4
5 4 4 4
5 5 4 5
Output
1
Input
6
1 1 1 1 1 1
5 5 5 5 5 5
Output
3
Input
1
5
3
Output
-1
Input
9
3 2 5 5 2 3 3 3 2
4 1 4 1 1 2 4 4 1
Output
4 | instruction | 0 | 62,800 | 17 | 125,600 |
Tags: constructive algorithms, math
Correct Solution:
```
n = int(input())
A = map(int, input().split())
B = map(int, input().split())
def count_performance(group):
count = [0] * 6
for performance in group:
count[performance] += 1
return count[1:]
A_performance = count_performance(A)
B_performance = count_performance(B)
exchanges = 0
possible = True
for a, b in zip(A_performance, B_performance):
diff = abs(a - b)
if diff & 1:
possible = False
break
exchanges += diff
print (exchanges // 4 if possible else -1)
``` | output | 1 | 62,800 | 17 | 125,601 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In Berland each high school student is characterized by academic performance — integer value between 1 and 5.
In high school 0xFF there are two groups of pupils: the group A and the group B. Each group consists of exactly n students. An academic performance of each student is known — integer value between 1 and 5.
The school director wants to redistribute students between groups so that each of the two groups has the same number of students whose academic performance is equal to 1, the same number of students whose academic performance is 2 and so on. In other words, the purpose of the school director is to change the composition of groups, so that for each value of academic performance the numbers of students in both groups are equal.
To achieve this, there is a plan to produce a series of exchanges of students between groups. During the single exchange the director selects one student from the class A and one student of class B. After that, they both change their groups.
Print the least number of exchanges, in order to achieve the desired equal numbers of students for each academic performance.
Input
The first line of the input contains integer number n (1 ≤ n ≤ 100) — number of students in both groups.
The second line contains sequence of integer numbers a1, a2, ..., an (1 ≤ ai ≤ 5), where ai is academic performance of the i-th student of the group A.
The third line contains sequence of integer numbers b1, b2, ..., bn (1 ≤ bi ≤ 5), where bi is academic performance of the i-th student of the group B.
Output
Print the required minimum number of exchanges or -1, if the desired distribution of students can not be obtained.
Examples
Input
4
5 4 4 4
5 5 4 5
Output
1
Input
6
1 1 1 1 1 1
5 5 5 5 5 5
Output
3
Input
1
5
3
Output
-1
Input
9
3 2 5 5 2 3 3 3 2
4 1 4 1 1 2 4 4 1
Output
4 | instruction | 0 | 62,801 | 17 | 125,602 |
Tags: constructive algorithms, math
Correct Solution:
```
n = int(input())
x1 = list(map(int, input().split()))
x2 = list(map(int, input().split()))
ans = 0
count1 = [0,0,0,0,0,0]
count2 = [0,0,0,0,0,0]
flag = True
for i in range(1, 6):
s = x1.count(i) + x2.count(i)
count1[i] = x1.count(i)
count2[i] = x2.count(i)
if(s%2==1):
flag = False
break
if(flag):
x1.sort()
x2.sort()
for i in range(1, 6):
for j in range(min(count1[i], count2[i])):
x1.remove(i)
x2.remove(i)
count1[i]-=1
count2[i]-=1
l = len(x1)
print(l//2)
else:
print(-1)
``` | output | 1 | 62,801 | 17 | 125,603 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In Berland each high school student is characterized by academic performance — integer value between 1 and 5.
In high school 0xFF there are two groups of pupils: the group A and the group B. Each group consists of exactly n students. An academic performance of each student is known — integer value between 1 and 5.
The school director wants to redistribute students between groups so that each of the two groups has the same number of students whose academic performance is equal to 1, the same number of students whose academic performance is 2 and so on. In other words, the purpose of the school director is to change the composition of groups, so that for each value of academic performance the numbers of students in both groups are equal.
To achieve this, there is a plan to produce a series of exchanges of students between groups. During the single exchange the director selects one student from the class A and one student of class B. After that, they both change their groups.
Print the least number of exchanges, in order to achieve the desired equal numbers of students for each academic performance.
Input
The first line of the input contains integer number n (1 ≤ n ≤ 100) — number of students in both groups.
The second line contains sequence of integer numbers a1, a2, ..., an (1 ≤ ai ≤ 5), where ai is academic performance of the i-th student of the group A.
The third line contains sequence of integer numbers b1, b2, ..., bn (1 ≤ bi ≤ 5), where bi is academic performance of the i-th student of the group B.
Output
Print the required minimum number of exchanges or -1, if the desired distribution of students can not be obtained.
Examples
Input
4
5 4 4 4
5 5 4 5
Output
1
Input
6
1 1 1 1 1 1
5 5 5 5 5 5
Output
3
Input
1
5
3
Output
-1
Input
9
3 2 5 5 2 3 3 3 2
4 1 4 1 1 2 4 4 1
Output
4 | instruction | 0 | 62,802 | 17 | 125,604 |
Tags: constructive algorithms, math
Correct Solution:
```
n = int(input().strip())
a = list(map(int, input().strip().split()))
b = list(map(int, input().strip().split()))
fa, fb = [0]*6, [0]*6
for i in range(n):
fa[a[i]] += 1
fb[b[i]] += 1
total = 0
for i, j in zip(fa, fb):
if (i+j)%2:
exit(print(-1))
total += abs(i-j)//2
print(total//2)
``` | output | 1 | 62,802 | 17 | 125,605 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In Berland each high school student is characterized by academic performance — integer value between 1 and 5.
In high school 0xFF there are two groups of pupils: the group A and the group B. Each group consists of exactly n students. An academic performance of each student is known — integer value between 1 and 5.
The school director wants to redistribute students between groups so that each of the two groups has the same number of students whose academic performance is equal to 1, the same number of students whose academic performance is 2 and so on. In other words, the purpose of the school director is to change the composition of groups, so that for each value of academic performance the numbers of students in both groups are equal.
To achieve this, there is a plan to produce a series of exchanges of students between groups. During the single exchange the director selects one student from the class A and one student of class B. After that, they both change their groups.
Print the least number of exchanges, in order to achieve the desired equal numbers of students for each academic performance.
Input
The first line of the input contains integer number n (1 ≤ n ≤ 100) — number of students in both groups.
The second line contains sequence of integer numbers a1, a2, ..., an (1 ≤ ai ≤ 5), where ai is academic performance of the i-th student of the group A.
The third line contains sequence of integer numbers b1, b2, ..., bn (1 ≤ bi ≤ 5), where bi is academic performance of the i-th student of the group B.
Output
Print the required minimum number of exchanges or -1, if the desired distribution of students can not be obtained.
Examples
Input
4
5 4 4 4
5 5 4 5
Output
1
Input
6
1 1 1 1 1 1
5 5 5 5 5 5
Output
3
Input
1
5
3
Output
-1
Input
9
3 2 5 5 2 3 3 3 2
4 1 4 1 1 2 4 4 1
Output
4 | instruction | 0 | 62,803 | 17 | 125,606 |
Tags: constructive algorithms, math
Correct Solution:
```
from collections import Counter
N = int(input())
A = map(int, input().strip().split())
B = map(int, input().strip().split())
a = Counter(A)
b = Counter(B)
cnt = 0
aa = 0
bb = 0
flag = False
for i in range(1,6):
diff = a[i]-b[i]
if diff % 2 == 1:
flag = True
break
if diff > 0:
aa += diff // 2
else:
bb += -diff // 2
if flag:
print(-1)
else:
if (aa == bb):
print(aa)
else:
print(-1)
``` | output | 1 | 62,803 | 17 | 125,607 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In Berland each high school student is characterized by academic performance — integer value between 1 and 5.
In high school 0xFF there are two groups of pupils: the group A and the group B. Each group consists of exactly n students. An academic performance of each student is known — integer value between 1 and 5.
The school director wants to redistribute students between groups so that each of the two groups has the same number of students whose academic performance is equal to 1, the same number of students whose academic performance is 2 and so on. In other words, the purpose of the school director is to change the composition of groups, so that for each value of academic performance the numbers of students in both groups are equal.
To achieve this, there is a plan to produce a series of exchanges of students between groups. During the single exchange the director selects one student from the class A and one student of class B. After that, they both change their groups.
Print the least number of exchanges, in order to achieve the desired equal numbers of students for each academic performance.
Input
The first line of the input contains integer number n (1 ≤ n ≤ 100) — number of students in both groups.
The second line contains sequence of integer numbers a1, a2, ..., an (1 ≤ ai ≤ 5), where ai is academic performance of the i-th student of the group A.
The third line contains sequence of integer numbers b1, b2, ..., bn (1 ≤ bi ≤ 5), where bi is academic performance of the i-th student of the group B.
Output
Print the required minimum number of exchanges or -1, if the desired distribution of students can not be obtained.
Examples
Input
4
5 4 4 4
5 5 4 5
Output
1
Input
6
1 1 1 1 1 1
5 5 5 5 5 5
Output
3
Input
1
5
3
Output
-1
Input
9
3 2 5 5 2 3 3 3 2
4 1 4 1 1 2 4 4 1
Output
4 | instruction | 0 | 62,804 | 17 | 125,608 |
Tags: constructive algorithms, math
Correct Solution:
```
""" Created by Shahen Kosyan on 2/26/17 """
if __name__ == '__main__':
n = int(input())
a = [int(x) for x in input().split()]
b = [int(x) for x in input().split()]
count = 0
a_dict = [a.count(1), a.count(2), a.count(3), a.count(4), a.count(5)]
b_dict = [b.count(1), b.count(2), b.count(3), b.count(4), b.count(5)]
possible = False
for i in range(5):
numbers_count = a_dict[i] + b_dict[i]
if numbers_count % 2 == 1:
possible = False
break
else:
possible = True
if a_dict[0] > b_dict[0]:
count += (a_dict[0] - b_dict[0]) // 2
if a_dict[1] > b_dict[1]:
count += (a_dict[1] - b_dict[1]) // 2
if a_dict[2] > b_dict[2]:
count += (a_dict[2] - b_dict[2]) // 2
if a_dict[3] > b_dict[3]:
count += (a_dict[3] - b_dict[3]) // 2
if a_dict[4] > b_dict[4]:
count += (a_dict[4] - b_dict[4]) // 2
if possible:
print(count)
else:
print('-1')
``` | output | 1 | 62,804 | 17 | 125,609 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In Berland each high school student is characterized by academic performance — integer value between 1 and 5.
In high school 0xFF there are two groups of pupils: the group A and the group B. Each group consists of exactly n students. An academic performance of each student is known — integer value between 1 and 5.
The school director wants to redistribute students between groups so that each of the two groups has the same number of students whose academic performance is equal to 1, the same number of students whose academic performance is 2 and so on. In other words, the purpose of the school director is to change the composition of groups, so that for each value of academic performance the numbers of students in both groups are equal.
To achieve this, there is a plan to produce a series of exchanges of students between groups. During the single exchange the director selects one student from the class A and one student of class B. After that, they both change their groups.
Print the least number of exchanges, in order to achieve the desired equal numbers of students for each academic performance.
Input
The first line of the input contains integer number n (1 ≤ n ≤ 100) — number of students in both groups.
The second line contains sequence of integer numbers a1, a2, ..., an (1 ≤ ai ≤ 5), where ai is academic performance of the i-th student of the group A.
The third line contains sequence of integer numbers b1, b2, ..., bn (1 ≤ bi ≤ 5), where bi is academic performance of the i-th student of the group B.
Output
Print the required minimum number of exchanges or -1, if the desired distribution of students can not be obtained.
Examples
Input
4
5 4 4 4
5 5 4 5
Output
1
Input
6
1 1 1 1 1 1
5 5 5 5 5 5
Output
3
Input
1
5
3
Output
-1
Input
9
3 2 5 5 2 3 3 3 2
4 1 4 1 1 2 4 4 1
Output
4
Submitted Solution:
```
n = int(input())
cnt = [0]*5
A = [int(i) - 1 for i in input().split()]
B = [int(i) - 1 for i in input().split()]
for i in A:
cnt[i] += 1
for i in B:
cnt[i] -= 1
res_4 = sum(abs(i) for i in cnt)
for i in cnt:
if i % 2 == 1:
print(-1)
exit()
if res_4 % 4 != 0:
print(-1)
else:
print(res_4 // 4)
``` | instruction | 0 | 62,805 | 17 | 125,610 |
Yes | output | 1 | 62,805 | 17 | 125,611 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In Berland each high school student is characterized by academic performance — integer value between 1 and 5.
In high school 0xFF there are two groups of pupils: the group A and the group B. Each group consists of exactly n students. An academic performance of each student is known — integer value between 1 and 5.
The school director wants to redistribute students between groups so that each of the two groups has the same number of students whose academic performance is equal to 1, the same number of students whose academic performance is 2 and so on. In other words, the purpose of the school director is to change the composition of groups, so that for each value of academic performance the numbers of students in both groups are equal.
To achieve this, there is a plan to produce a series of exchanges of students between groups. During the single exchange the director selects one student from the class A and one student of class B. After that, they both change their groups.
Print the least number of exchanges, in order to achieve the desired equal numbers of students for each academic performance.
Input
The first line of the input contains integer number n (1 ≤ n ≤ 100) — number of students in both groups.
The second line contains sequence of integer numbers a1, a2, ..., an (1 ≤ ai ≤ 5), where ai is academic performance of the i-th student of the group A.
The third line contains sequence of integer numbers b1, b2, ..., bn (1 ≤ bi ≤ 5), where bi is academic performance of the i-th student of the group B.
Output
Print the required minimum number of exchanges or -1, if the desired distribution of students can not be obtained.
Examples
Input
4
5 4 4 4
5 5 4 5
Output
1
Input
6
1 1 1 1 1 1
5 5 5 5 5 5
Output
3
Input
1
5
3
Output
-1
Input
9
3 2 5 5 2 3 3 3 2
4 1 4 1 1 2 4 4 1
Output
4
Submitted Solution:
```
""" Created by Henrikh Kantuni on 2/26/17 """
if __name__ == "__main__":
n = int(input())
al = [int(x) for x in input().split()]
bl = [int(x) for x in input().split()]
a = {
1: al.count(1),
2: al.count(2),
3: al.count(3),
4: al.count(4),
5: al.count(5),
}
b = {
1: bl.count(1),
2: bl.count(2),
3: bl.count(3),
4: bl.count(4),
5: bl.count(5),
}
possible = True
for key in a.keys():
if (a[key] + b[key]) % 2 != 0:
possible = False
break
if possible:
swaps = 0
for key in a.keys():
if a[key] > b[key]:
swaps += (a[key] - b[key]) // 2
print(swaps)
else:
print(-1)
``` | instruction | 0 | 62,806 | 17 | 125,612 |
Yes | output | 1 | 62,806 | 17 | 125,613 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In Berland each high school student is characterized by academic performance — integer value between 1 and 5.
In high school 0xFF there are two groups of pupils: the group A and the group B. Each group consists of exactly n students. An academic performance of each student is known — integer value between 1 and 5.
The school director wants to redistribute students between groups so that each of the two groups has the same number of students whose academic performance is equal to 1, the same number of students whose academic performance is 2 and so on. In other words, the purpose of the school director is to change the composition of groups, so that for each value of academic performance the numbers of students in both groups are equal.
To achieve this, there is a plan to produce a series of exchanges of students between groups. During the single exchange the director selects one student from the class A and one student of class B. After that, they both change their groups.
Print the least number of exchanges, in order to achieve the desired equal numbers of students for each academic performance.
Input
The first line of the input contains integer number n (1 ≤ n ≤ 100) — number of students in both groups.
The second line contains sequence of integer numbers a1, a2, ..., an (1 ≤ ai ≤ 5), where ai is academic performance of the i-th student of the group A.
The third line contains sequence of integer numbers b1, b2, ..., bn (1 ≤ bi ≤ 5), where bi is academic performance of the i-th student of the group B.
Output
Print the required minimum number of exchanges or -1, if the desired distribution of students can not be obtained.
Examples
Input
4
5 4 4 4
5 5 4 5
Output
1
Input
6
1 1 1 1 1 1
5 5 5 5 5 5
Output
3
Input
1
5
3
Output
-1
Input
9
3 2 5 5 2 3 3 3 2
4 1 4 1 1 2 4 4 1
Output
4
Submitted Solution:
```
n=int(input())
a=[]
b=[]
y=input()
x=y.split()
for i in range(n):
a.append(int(x[i]))
y=input()
x=y.split()
for i in range(n):
b.append(int(x[i]))
a1=abs(a.count(1)-b.count(1))
a2=abs(a.count(2)-b.count(2))
a3=abs(a.count(3)-b.count(3))
a4=abs(a.count(4)-b.count(4))
a5=abs(a.count(5)-b.count(5))
j=[a1,a2,a3,a4,a5]
j.sort()
if(a1%2==0 and a2%2==0 and a3%2==0 and a4%2==0 and a5%2==0):
if(((j[4]+j[3]+j[2]+j[1]+j[0])/2)%2==0):
print(int((j[4]+j[3]+j[2]+j[1]+j[0])/4))
else:
print(-1)
else:
print(-1)
``` | instruction | 0 | 62,807 | 17 | 125,614 |
Yes | output | 1 | 62,807 | 17 | 125,615 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In Berland each high school student is characterized by academic performance — integer value between 1 and 5.
In high school 0xFF there are two groups of pupils: the group A and the group B. Each group consists of exactly n students. An academic performance of each student is known — integer value between 1 and 5.
The school director wants to redistribute students between groups so that each of the two groups has the same number of students whose academic performance is equal to 1, the same number of students whose academic performance is 2 and so on. In other words, the purpose of the school director is to change the composition of groups, so that for each value of academic performance the numbers of students in both groups are equal.
To achieve this, there is a plan to produce a series of exchanges of students between groups. During the single exchange the director selects one student from the class A and one student of class B. After that, they both change their groups.
Print the least number of exchanges, in order to achieve the desired equal numbers of students for each academic performance.
Input
The first line of the input contains integer number n (1 ≤ n ≤ 100) — number of students in both groups.
The second line contains sequence of integer numbers a1, a2, ..., an (1 ≤ ai ≤ 5), where ai is academic performance of the i-th student of the group A.
The third line contains sequence of integer numbers b1, b2, ..., bn (1 ≤ bi ≤ 5), where bi is academic performance of the i-th student of the group B.
Output
Print the required minimum number of exchanges or -1, if the desired distribution of students can not be obtained.
Examples
Input
4
5 4 4 4
5 5 4 5
Output
1
Input
6
1 1 1 1 1 1
5 5 5 5 5 5
Output
3
Input
1
5
3
Output
-1
Input
9
3 2 5 5 2 3 3 3 2
4 1 4 1 1 2 4 4 1
Output
4
Submitted Solution:
```
n = int(input())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
fra = [0] * 6
frb = [0] * 6
for i in a:
fra[i] += 1
for i in b:
frb[i] += 1
p = 0
ans = 0
f = True
for i in range(1, 6):
r = fra[i] - frb[i]
if r % 2 == 1:
f = False
break
else:
if r >= 0:
ans += (r // 2)
p += (r // 2)
else:
p += (r // 2)
if f and p == 0:
print(ans)
else:
print(-1)
``` | instruction | 0 | 62,808 | 17 | 125,616 |
Yes | output | 1 | 62,808 | 17 | 125,617 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In Berland each high school student is characterized by academic performance — integer value between 1 and 5.
In high school 0xFF there are two groups of pupils: the group A and the group B. Each group consists of exactly n students. An academic performance of each student is known — integer value between 1 and 5.
The school director wants to redistribute students between groups so that each of the two groups has the same number of students whose academic performance is equal to 1, the same number of students whose academic performance is 2 and so on. In other words, the purpose of the school director is to change the composition of groups, so that for each value of academic performance the numbers of students in both groups are equal.
To achieve this, there is a plan to produce a series of exchanges of students between groups. During the single exchange the director selects one student from the class A and one student of class B. After that, they both change their groups.
Print the least number of exchanges, in order to achieve the desired equal numbers of students for each academic performance.
Input
The first line of the input contains integer number n (1 ≤ n ≤ 100) — number of students in both groups.
The second line contains sequence of integer numbers a1, a2, ..., an (1 ≤ ai ≤ 5), where ai is academic performance of the i-th student of the group A.
The third line contains sequence of integer numbers b1, b2, ..., bn (1 ≤ bi ≤ 5), where bi is academic performance of the i-th student of the group B.
Output
Print the required minimum number of exchanges or -1, if the desired distribution of students can not be obtained.
Examples
Input
4
5 4 4 4
5 5 4 5
Output
1
Input
6
1 1 1 1 1 1
5 5 5 5 5 5
Output
3
Input
1
5
3
Output
-1
Input
9
3 2 5 5 2 3 3 3 2
4 1 4 1 1 2 4 4 1
Output
4
Submitted Solution:
```
import collections
n = int(input())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
acnt = collections.Counter(a)
abcnt = collections.Counter(a+b)
ans = 0
for k, v in abcnt.items():
if v & 1:
ans = -1
break
ans += (v - acnt[k]) // 2
print(ans)
``` | instruction | 0 | 62,809 | 17 | 125,618 |
No | output | 1 | 62,809 | 17 | 125,619 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In Berland each high school student is characterized by academic performance — integer value between 1 and 5.
In high school 0xFF there are two groups of pupils: the group A and the group B. Each group consists of exactly n students. An academic performance of each student is known — integer value between 1 and 5.
The school director wants to redistribute students between groups so that each of the two groups has the same number of students whose academic performance is equal to 1, the same number of students whose academic performance is 2 and so on. In other words, the purpose of the school director is to change the composition of groups, so that for each value of academic performance the numbers of students in both groups are equal.
To achieve this, there is a plan to produce a series of exchanges of students between groups. During the single exchange the director selects one student from the class A and one student of class B. After that, they both change their groups.
Print the least number of exchanges, in order to achieve the desired equal numbers of students for each academic performance.
Input
The first line of the input contains integer number n (1 ≤ n ≤ 100) — number of students in both groups.
The second line contains sequence of integer numbers a1, a2, ..., an (1 ≤ ai ≤ 5), where ai is academic performance of the i-th student of the group A.
The third line contains sequence of integer numbers b1, b2, ..., bn (1 ≤ bi ≤ 5), where bi is academic performance of the i-th student of the group B.
Output
Print the required minimum number of exchanges or -1, if the desired distribution of students can not be obtained.
Examples
Input
4
5 4 4 4
5 5 4 5
Output
1
Input
6
1 1 1 1 1 1
5 5 5 5 5 5
Output
3
Input
1
5
3
Output
-1
Input
9
3 2 5 5 2 3 3 3 2
4 1 4 1 1 2 4 4 1
Output
4
Submitted Solution:
```
import sys,os
from io import BytesIO, IOBase
import collections,itertools,bisect,heapq,math,string
# region fastio
BUFSIZE = 8192
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 main():
n = int(input())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
c = {}
d = {}
for i in range(n):
if a[i] in c:
c[a[i]] += 1
else:
c[a[i]] = 1
for i in range(n):
if b[i] in d:
d[b[i]] += 1
else:
d[b[i]] = 1
#print(c)
#print(d)
e = 0
l = 0
#g = []
#h = []
k = []
m = 0
if n == 1:
if a == b:
print(0)
else:
print(-1)
else:
for i in c:
if i in d:
m += 1
if c[i] == d[i]:
continue
else:
e = abs(c[i]+d[i])
if e%2 == 0:
l = e//2
k.append(l//2)
else:
k.append(-100)
#g.append(e//2)
else:
e = abs(c[i])
if e%2 == 0:
l = e//2
k.append(l)
else:
k.append(-100)
m = m//2
g = sum(k)-m
if(len(k) == 0):
g = 0
if g < 0:
g = -1
print(g)
if __name__ == "__main__":
main()
``` | instruction | 0 | 62,810 | 17 | 125,620 |
No | output | 1 | 62,810 | 17 | 125,621 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In Berland each high school student is characterized by academic performance — integer value between 1 and 5.
In high school 0xFF there are two groups of pupils: the group A and the group B. Each group consists of exactly n students. An academic performance of each student is known — integer value between 1 and 5.
The school director wants to redistribute students between groups so that each of the two groups has the same number of students whose academic performance is equal to 1, the same number of students whose academic performance is 2 and so on. In other words, the purpose of the school director is to change the composition of groups, so that for each value of academic performance the numbers of students in both groups are equal.
To achieve this, there is a plan to produce a series of exchanges of students between groups. During the single exchange the director selects one student from the class A and one student of class B. After that, they both change their groups.
Print the least number of exchanges, in order to achieve the desired equal numbers of students for each academic performance.
Input
The first line of the input contains integer number n (1 ≤ n ≤ 100) — number of students in both groups.
The second line contains sequence of integer numbers a1, a2, ..., an (1 ≤ ai ≤ 5), where ai is academic performance of the i-th student of the group A.
The third line contains sequence of integer numbers b1, b2, ..., bn (1 ≤ bi ≤ 5), where bi is academic performance of the i-th student of the group B.
Output
Print the required minimum number of exchanges or -1, if the desired distribution of students can not be obtained.
Examples
Input
4
5 4 4 4
5 5 4 5
Output
1
Input
6
1 1 1 1 1 1
5 5 5 5 5 5
Output
3
Input
1
5
3
Output
-1
Input
9
3 2 5 5 2 3 3 3 2
4 1 4 1 1 2 4 4 1
Output
4
Submitted Solution:
```
def pupils(lst1, lst2):
count = 0
for i in range(1, 6):
t = abs(lst1[i] - lst2[i])
if t % 2 == 1:
return -1
count += t // 2
return count // 2
n = int(input())
a = [int(j) for j in input().split()]
b = [int(z) for z in input().split()]
print(pupils(a, b))
``` | instruction | 0 | 62,811 | 17 | 125,622 |
No | output | 1 | 62,811 | 17 | 125,623 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In Berland each high school student is characterized by academic performance — integer value between 1 and 5.
In high school 0xFF there are two groups of pupils: the group A and the group B. Each group consists of exactly n students. An academic performance of each student is known — integer value between 1 and 5.
The school director wants to redistribute students between groups so that each of the two groups has the same number of students whose academic performance is equal to 1, the same number of students whose academic performance is 2 and so on. In other words, the purpose of the school director is to change the composition of groups, so that for each value of academic performance the numbers of students in both groups are equal.
To achieve this, there is a plan to produce a series of exchanges of students between groups. During the single exchange the director selects one student from the class A and one student of class B. After that, they both change their groups.
Print the least number of exchanges, in order to achieve the desired equal numbers of students for each academic performance.
Input
The first line of the input contains integer number n (1 ≤ n ≤ 100) — number of students in both groups.
The second line contains sequence of integer numbers a1, a2, ..., an (1 ≤ ai ≤ 5), where ai is academic performance of the i-th student of the group A.
The third line contains sequence of integer numbers b1, b2, ..., bn (1 ≤ bi ≤ 5), where bi is academic performance of the i-th student of the group B.
Output
Print the required minimum number of exchanges or -1, if the desired distribution of students can not be obtained.
Examples
Input
4
5 4 4 4
5 5 4 5
Output
1
Input
6
1 1 1 1 1 1
5 5 5 5 5 5
Output
3
Input
1
5
3
Output
-1
Input
9
3 2 5 5 2 3 3 3 2
4 1 4 1 1 2 4 4 1
Output
4
Submitted Solution:
```
import sys
from math import ceil
read=lambda:sys.stdin.readline().strip()
write=lambda x:sys.stdout.write(x+"\n")
N=int(read())
SA=list(map(int, read().split()));
SB=list(map(int, read().split()));
arrA = [0 for _ in range(5)]
arrB = [0 for _ in range(5)]
for i in range(N):
arrA[SA[i]-1] += 1
arrB[SB[i]-1] += 1
result = 0
for i in range(5):
s = arrA[i] + arrB[i]
diff = abs(arrA[i]-arrB[i])
diff /= 2
if s % 2:
result = -1
break
result += diff
if result > 0:
result = int(ceil(result/2))
write(str(result))
``` | instruction | 0 | 62,812 | 17 | 125,624 |
No | output | 1 | 62,812 | 17 | 125,625 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is an interactive problem.
You are the head coach of a chess club. The club has 2n players, each player has some strength which can be represented by a number, and all those numbers are distinct. The strengths of the players are not known to you.
You need to select n players who would represent your club in the upcoming championship. Naturally, you want to select n players with the highest strengths.
You can organize matches between the players to do that. In every match, you pick two players, they play some games, and you learn which one of the two has higher strength. You can wait for the outcome of a match before deciding who will participate in the next one.
However, you do not want to know exactly how those n players compare between themselves, as that would make the championship itself less intriguing. More formally, you must reach a state where there is exactly one way to choose n players with the highest strengths that is consistent with the outcomes of the matches you organized, but there must be at least two possible orderings of those n players by strength that are consistent with the outcomes of the matches you organized.
Interaction
Your program has to process multiple test cases in one run. First, it should read the integer t (t ≥ 1) — the number of test cases. Then, it should process the test cases one by one.
In each test case, your program should start by reading the integer n (3 ≤ n ≤ 100) — the number of players to select out of 2n players. The sum of squares of the values of n over all test cases does not exceed 10 000.
Then your program can organize matches zero or more times. To organize a match, your program should print a match description formatted as ? i j — a question mark followed by two distinct numbers of players participating in the match. The players are numbered from 1 to 2n, inclusive. Remember to flush the output after printing the match description. Then your program should read the match outcome — it will be either the greater-than character (>), if the first player in the match description has higher strength, or the less-than character (<), if the second player in the match description has higher strength.
Your program can organize at most 4n^2 matches. After it is done organizing matches, it should print the exclamation mark (!) and continue to the next test case, or exit gracefully if this was the last test case. Remember to flush the output after printing the exclamation mark.
There must be exactly one way to choose n players with the highest strength that is consistent with the outcomes of the matches you organized, but there must be at least two possible orderings of those n players by their strength that are consistent with the outcomes of the matches you organized.
The judging program picks some distinct numbers as the strengths of all players before your program starts organizing matches and uses them to answer the requests.
Example
Input
2
3
>
<
>
<
>
>
3
<
<
<
>
>
Output
? 1 3
? 4 2
? 4 5
? 6 5
? 3 4
? 5 6
!
? 3 4
? 4 2
? 5 3
? 6 4
? 3 1
!
Note
In the example, the players in the first test case are sorted by strength in decreasing order. From the matches in the example output, we can deduce that players 1, 2, and 3 have the highest strength, but we do not know how the player 1 compares to the player 2.
Submitted Solution:
```
import sys
input = sys.stdin.readline
def query(a, b):
print("?", a+1, b+1, flush = True)
t = int(input())
for __ in range(t):
n = int(input())
good = set()
bad = set()
for i in range(n):
query(i, i + n)
s = input().strip()
if s == "<":
good.add(i + n)
bad.add(i)
else:
good.add(i)
bad.add(i + n)
for i in range(n):
worst = -1
for test in bad:
if worst == -1:
worst = test
else:
query(worst, test)
sp = input().strip()
if sp == ">":
worst = test
bad.remove(worst)
nex = (worst + n) % (2 * n)
if nex in good:
good.remove(nex)
bad.add(nex)
if __ != t - 1:
print('!', flush = True)
``` | instruction | 0 | 63,253 | 17 | 126,506 |
No | output | 1 | 63,253 | 17 | 126,507 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is an interactive problem.
You are the head coach of a chess club. The club has 2n players, each player has some strength which can be represented by a number, and all those numbers are distinct. The strengths of the players are not known to you.
You need to select n players who would represent your club in the upcoming championship. Naturally, you want to select n players with the highest strengths.
You can organize matches between the players to do that. In every match, you pick two players, they play some games, and you learn which one of the two has higher strength. You can wait for the outcome of a match before deciding who will participate in the next one.
However, you do not want to know exactly how those n players compare between themselves, as that would make the championship itself less intriguing. More formally, you must reach a state where there is exactly one way to choose n players with the highest strengths that is consistent with the outcomes of the matches you organized, but there must be at least two possible orderings of those n players by strength that are consistent with the outcomes of the matches you organized.
Interaction
Your program has to process multiple test cases in one run. First, it should read the integer t (t ≥ 1) — the number of test cases. Then, it should process the test cases one by one.
In each test case, your program should start by reading the integer n (3 ≤ n ≤ 100) — the number of players to select out of 2n players. The sum of squares of the values of n over all test cases does not exceed 10 000.
Then your program can organize matches zero or more times. To organize a match, your program should print a match description formatted as ? i j — a question mark followed by two distinct numbers of players participating in the match. The players are numbered from 1 to 2n, inclusive. Remember to flush the output after printing the match description. Then your program should read the match outcome — it will be either the greater-than character (>), if the first player in the match description has higher strength, or the less-than character (<), if the second player in the match description has higher strength.
Your program can organize at most 4n^2 matches. After it is done organizing matches, it should print the exclamation mark (!) and continue to the next test case, or exit gracefully if this was the last test case. Remember to flush the output after printing the exclamation mark.
There must be exactly one way to choose n players with the highest strength that is consistent with the outcomes of the matches you organized, but there must be at least two possible orderings of those n players by their strength that are consistent with the outcomes of the matches you organized.
The judging program picks some distinct numbers as the strengths of all players before your program starts organizing matches and uses them to answer the requests.
Example
Input
2
3
>
<
>
<
>
>
3
<
<
<
>
>
Output
? 1 3
? 4 2
? 4 5
? 6 5
? 3 4
? 5 6
!
? 3 4
? 4 2
? 5 3
? 6 4
? 3 1
!
Note
In the example, the players in the first test case are sorted by strength in decreasing order. From the matches in the example output, we can deduce that players 1, 2, and 3 have the highest strength, but we do not know how the player 1 compares to the player 2.
Submitted Solution:
```
def main():
def solve():
n = int(input())
arr = [[0] * (2 * n) for _ in range(2 * n)]
def query(a, b):
if not arr[a][b]:
print("? {} {}".format(a + 1, b + 1), flush=True)
tmp = input()
if tmp == '<':
arr[a][b] = -1
arr[b][a] = 1
else:
arr[a][b] = 1
arr[b][a] = -1
return arr[a][b]
def reduce(*arr):
winners = []
losers = []
for i in range(3):
q = query(arr[2 * i], arr[2 * i + 1])
if q == -1:
losers.append(arr[2 * i])
winners.append(arr[2 * i + 1])
else:
losers.append(arr[2 * i + 1])
winners.append(arr[2 * i])
wins = [0] * 3
for i in range(3):
for j in range(i + 1, 3):
q = query(losers[i], losers[j])
if q == 1:
wins[i] += 1
else:
wins[j] += 1
d = -1
for i in range(3):
if wins[i] == 2:
winners[0], winners[i] = winners[i], winners[0]
d = losers[i]
a, b, c = winners
return a, d, b, c
if n == 3:
a, d, b, c = reduce(*range(6))
if query(b, c) == 1:
query(d, c)
else:
query(d, b)
else:
a, d, b, c = reduce(*range(6))
for i in range(6, 2 * n, 2):
a, d, b, c = reduce(a, d, b, c, i, i + 1)
for i in range(2 * n):
if i == b or i == c:
continue
query(i, b)
query(i, c)
for j in range(2 * n):
if j == i or j == b or j == c:
continue
query(i, j)
print("!", flush=True)
for _ in range(int(input())):
solve()
return 0
main()
``` | instruction | 0 | 63,254 | 17 | 126,508 |
No | output | 1 | 63,254 | 17 | 126,509 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is an interactive problem.
You are the head coach of a chess club. The club has 2n players, each player has some strength which can be represented by a number, and all those numbers are distinct. The strengths of the players are not known to you.
You need to select n players who would represent your club in the upcoming championship. Naturally, you want to select n players with the highest strengths.
You can organize matches between the players to do that. In every match, you pick two players, they play some games, and you learn which one of the two has higher strength. You can wait for the outcome of a match before deciding who will participate in the next one.
However, you do not want to know exactly how those n players compare between themselves, as that would make the championship itself less intriguing. More formally, you must reach a state where there is exactly one way to choose n players with the highest strengths that is consistent with the outcomes of the matches you organized, but there must be at least two possible orderings of those n players by strength that are consistent with the outcomes of the matches you organized.
Interaction
Your program has to process multiple test cases in one run. First, it should read the integer t (t ≥ 1) — the number of test cases. Then, it should process the test cases one by one.
In each test case, your program should start by reading the integer n (3 ≤ n ≤ 100) — the number of players to select out of 2n players. The sum of squares of the values of n over all test cases does not exceed 10 000.
Then your program can organize matches zero or more times. To organize a match, your program should print a match description formatted as ? i j — a question mark followed by two distinct numbers of players participating in the match. The players are numbered from 1 to 2n, inclusive. Remember to flush the output after printing the match description. Then your program should read the match outcome — it will be either the greater-than character (>), if the first player in the match description has higher strength, or the less-than character (<), if the second player in the match description has higher strength.
Your program can organize at most 4n^2 matches. After it is done organizing matches, it should print the exclamation mark (!) and continue to the next test case, or exit gracefully if this was the last test case. Remember to flush the output after printing the exclamation mark.
There must be exactly one way to choose n players with the highest strength that is consistent with the outcomes of the matches you organized, but there must be at least two possible orderings of those n players by their strength that are consistent with the outcomes of the matches you organized.
The judging program picks some distinct numbers as the strengths of all players before your program starts organizing matches and uses them to answer the requests.
Example
Input
2
3
>
<
>
<
>
>
3
<
<
<
>
>
Output
? 1 3
? 4 2
? 4 5
? 6 5
? 3 4
? 5 6
!
? 3 4
? 4 2
? 5 3
? 6 4
? 3 1
!
Note
In the example, the players in the first test case are sorted by strength in decreasing order. From the matches in the example output, we can deduce that players 1, 2, and 3 have the highest strength, but we do not know how the player 1 compares to the player 2.
Submitted Solution:
```
def main():
def solve():
n = int(input())
arr = [[0] * (2 * n) for _ in range(2 * n)]
def query(a, b):
print(a, b)
if not arr[a][b]:
print("? {} {}".format(a + 1, b + 1), flush=True)
tmp = input()
if tmp == '<':
arr[a][b] = -1
arr[b][a] = 1
else:
arr[a][b] = 1
arr[b][a] = -1
return arr[a][b]
def reduce(*arr):
winners = []
losers = []
for i in range(3):
q = query(arr[2 * i], arr[2 * i + 1])
if q == -1:
losers.append(arr[2 * i])
winners.append(arr[2 * i + 1])
else:
losers.append(arr[2 * i + 1])
winners.append(arr[2 * i])
wins = [0] * 3
for i in range(3):
for j in range(i + 1, 3):
q = query(losers[i], losers[j])
if q == 1:
wins[i] += 1
else:
wins[j] += 1
d = -1
for i in range(3):
if wins[i] == 2:
winners[0], winners[i] = winners[i], winners[0]
d = losers[i]
a, b, c = winners
return a, d, b, c
if n == 3:
a, d, b, c = reduce(*range(6))
if query(b, c) == 1:
query(d, c)
else:
query(d, b)
else:
a, d, b, c = reduce(*range(6))
for i in range(6, 2 * n, 2):
a, d, b, c = reduce(a, d, b, c, i, i + 1)
for i in range(2 * n):
if i == b or i == c:
continue
query(i, b)
query(i, c)
for j in range(2 * n):
if j == i or j == b or j == c:
continue
query(i, j)
print("!", flush=True)
for _ in range(int(input())):
solve()
return 0
main()
``` | instruction | 0 | 63,255 | 17 | 126,510 |
No | output | 1 | 63,255 | 17 | 126,511 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is an interactive problem.
You are the head coach of a chess club. The club has 2n players, each player has some strength which can be represented by a number, and all those numbers are distinct. The strengths of the players are not known to you.
You need to select n players who would represent your club in the upcoming championship. Naturally, you want to select n players with the highest strengths.
You can organize matches between the players to do that. In every match, you pick two players, they play some games, and you learn which one of the two has higher strength. You can wait for the outcome of a match before deciding who will participate in the next one.
However, you do not want to know exactly how those n players compare between themselves, as that would make the championship itself less intriguing. More formally, you must reach a state where there is exactly one way to choose n players with the highest strengths that is consistent with the outcomes of the matches you organized, but there must be at least two possible orderings of those n players by strength that are consistent with the outcomes of the matches you organized.
Interaction
Your program has to process multiple test cases in one run. First, it should read the integer t (t ≥ 1) — the number of test cases. Then, it should process the test cases one by one.
In each test case, your program should start by reading the integer n (3 ≤ n ≤ 100) — the number of players to select out of 2n players. The sum of squares of the values of n over all test cases does not exceed 10 000.
Then your program can organize matches zero or more times. To organize a match, your program should print a match description formatted as ? i j — a question mark followed by two distinct numbers of players participating in the match. The players are numbered from 1 to 2n, inclusive. Remember to flush the output after printing the match description. Then your program should read the match outcome — it will be either the greater-than character (>), if the first player in the match description has higher strength, or the less-than character (<), if the second player in the match description has higher strength.
Your program can organize at most 4n^2 matches. After it is done organizing matches, it should print the exclamation mark (!) and continue to the next test case, or exit gracefully if this was the last test case. Remember to flush the output after printing the exclamation mark.
There must be exactly one way to choose n players with the highest strength that is consistent with the outcomes of the matches you organized, but there must be at least two possible orderings of those n players by their strength that are consistent with the outcomes of the matches you organized.
The judging program picks some distinct numbers as the strengths of all players before your program starts organizing matches and uses them to answer the requests.
Example
Input
2
3
>
<
>
<
>
>
3
<
<
<
>
>
Output
? 1 3
? 4 2
? 4 5
? 6 5
? 3 4
? 5 6
!
? 3 4
? 4 2
? 5 3
? 6 4
? 3 1
!
Note
In the example, the players in the first test case are sorted by strength in decreasing order. From the matches in the example output, we can deduce that players 1, 2, and 3 have the highest strength, but we do not know how the player 1 compares to the player 2.
Submitted Solution:
```
import sys
input = sys.stdin.readline
def query(a, b):
print("?", a+1, b+1, flush = True)
t = int(input())
for __ in range(t):
n = int(input())
good = set()
bad = set()
for i in range(n):
query(i, i + n)
s = input().strip()
if s == "<":
good.add(i + n)
bad.add(i)
else:
good.add(i)
bad.add(i + n)
best = -1
for test in bad:
if best == -1:
best = test
else:
query(best, test)
sp = input().strip()
if sp == "<":
best = test
bad.remove(best)
for i in range(n):
worst = -1
for test in bad:
if worst == -1:
worst = test
else:
query(worst, test)
sp = input().strip()
if sp == ">":
worst = test
bad.remove(worst)
nex = (worst + n) % (2 * n)
if nex in good:
good.remove(nex)
bad.add(nex)
query(best, worst)
input()
if __ != t - 1:
print('!', flush = True)
``` | instruction | 0 | 63,256 | 17 | 126,512 |
No | output | 1 | 63,256 | 17 | 126,513 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n people participating in some contest, they start participating in x minutes intervals. That means the first participant starts at time 0, the second participant starts at time x, the third — at time 2 ⋅ x, and so on.
Duration of contest is t minutes for each participant, so the first participant finishes the contest at time t, the second — at time t + x, and so on. When a participant finishes the contest, their dissatisfaction equals to the number of participants that started the contest (or starting it now), but haven't yet finished it.
Determine the sum of dissatisfaction of all participants.
Input
The first line contains a single integer k (1 ≤ k ≤ 1000) — the number of test cases.
Each of the next k lines contains three integers n, x, t (1 ≤ n, x, t ≤ 2 ⋅ 10^9) — the number of participants, the start interval and the contest duration.
Output
Print k lines, in the i-th line print the total dissatisfaction of participants in the i-th test case.
Example
Input
4
4 2 5
3 1 2
3 3 10
2000000000 1 2000000000
Output
5
3
3
1999999999000000000
Note
In the first example the first participant starts at 0 and finishes at time 5. By that time the second and the third participants start, so the dissatisfaction of the first participant is 2.
The second participant starts at time 2 and finishes at time 7. By that time the third the fourth participants start, so the dissatisfaction of the second participant is 2.
The third participant starts at 4 and finishes at 9. By that time the fourth participant starts, so the dissatisfaction of the third participant is 1.
The fourth participant starts at 6 and finishes at 11. By time 11 everyone finishes the contest, so the dissatisfaction of the fourth participant is 0.
In the second example the first participant starts at 0 and finishes at time 2. By that time the second participants starts, and the third starts at exactly time 2. So the dissatisfaction of the first participant is 2.
The second participant starts at time 1 and finishes at time 3. At that time the third participant is solving the contest. | instruction | 0 | 63,386 | 17 | 126,772 |
Tags: combinatorics, geometry, greedy, math
Correct Solution:
```
for i in range(int(input())):
n, x, t = map(int, input().split())
ans = max(0, n-t//x) * (t//x) + min(n-1, t//x - 1) * min(n, t//x)//2
print(ans)
``` | output | 1 | 63,386 | 17 | 126,773 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n people participating in some contest, they start participating in x minutes intervals. That means the first participant starts at time 0, the second participant starts at time x, the third — at time 2 ⋅ x, and so on.
Duration of contest is t minutes for each participant, so the first participant finishes the contest at time t, the second — at time t + x, and so on. When a participant finishes the contest, their dissatisfaction equals to the number of participants that started the contest (or starting it now), but haven't yet finished it.
Determine the sum of dissatisfaction of all participants.
Input
The first line contains a single integer k (1 ≤ k ≤ 1000) — the number of test cases.
Each of the next k lines contains three integers n, x, t (1 ≤ n, x, t ≤ 2 ⋅ 10^9) — the number of participants, the start interval and the contest duration.
Output
Print k lines, in the i-th line print the total dissatisfaction of participants in the i-th test case.
Example
Input
4
4 2 5
3 1 2
3 3 10
2000000000 1 2000000000
Output
5
3
3
1999999999000000000
Note
In the first example the first participant starts at 0 and finishes at time 5. By that time the second and the third participants start, so the dissatisfaction of the first participant is 2.
The second participant starts at time 2 and finishes at time 7. By that time the third the fourth participants start, so the dissatisfaction of the second participant is 2.
The third participant starts at 4 and finishes at 9. By that time the fourth participant starts, so the dissatisfaction of the third participant is 1.
The fourth participant starts at 6 and finishes at 11. By time 11 everyone finishes the contest, so the dissatisfaction of the fourth participant is 0.
In the second example the first participant starts at 0 and finishes at time 2. By that time the second participants starts, and the third starts at exactly time 2. So the dissatisfaction of the first participant is 2.
The second participant starts at time 1 and finishes at time 3. At that time the third participant is solving the contest. | instruction | 0 | 63,387 | 17 | 126,774 |
Tags: combinatorics, geometry, greedy, math
Correct Solution:
```
for t in range(int(input())):
n,x, k = map(int, input().split())
v = k//x
if(n>=v):
c = (v)*(n-v) + (v)*(v -1)//2
else:
c = n*(n-1)//2
print(c)
``` | output | 1 | 63,387 | 17 | 126,775 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n people participating in some contest, they start participating in x minutes intervals. That means the first participant starts at time 0, the second participant starts at time x, the third — at time 2 ⋅ x, and so on.
Duration of contest is t minutes for each participant, so the first participant finishes the contest at time t, the second — at time t + x, and so on. When a participant finishes the contest, their dissatisfaction equals to the number of participants that started the contest (or starting it now), but haven't yet finished it.
Determine the sum of dissatisfaction of all participants.
Input
The first line contains a single integer k (1 ≤ k ≤ 1000) — the number of test cases.
Each of the next k lines contains three integers n, x, t (1 ≤ n, x, t ≤ 2 ⋅ 10^9) — the number of participants, the start interval and the contest duration.
Output
Print k lines, in the i-th line print the total dissatisfaction of participants in the i-th test case.
Example
Input
4
4 2 5
3 1 2
3 3 10
2000000000 1 2000000000
Output
5
3
3
1999999999000000000
Note
In the first example the first participant starts at 0 and finishes at time 5. By that time the second and the third participants start, so the dissatisfaction of the first participant is 2.
The second participant starts at time 2 and finishes at time 7. By that time the third the fourth participants start, so the dissatisfaction of the second participant is 2.
The third participant starts at 4 and finishes at 9. By that time the fourth participant starts, so the dissatisfaction of the third participant is 1.
The fourth participant starts at 6 and finishes at 11. By time 11 everyone finishes the contest, so the dissatisfaction of the fourth participant is 0.
In the second example the first participant starts at 0 and finishes at time 2. By that time the second participants starts, and the third starts at exactly time 2. So the dissatisfaction of the first participant is 2.
The second participant starts at time 1 and finishes at time 3. At that time the third participant is solving the contest. | instruction | 0 | 63,388 | 17 | 126,776 |
Tags: combinatorics, geometry, greedy, math
Correct Solution:
```
for _ in range(int(input())):
n, x, t = map(int, input().split())
d = min(n,t//x)
print(d * (2*n-d-1)//2)
``` | output | 1 | 63,388 | 17 | 126,777 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n people participating in some contest, they start participating in x minutes intervals. That means the first participant starts at time 0, the second participant starts at time x, the third — at time 2 ⋅ x, and so on.
Duration of contest is t minutes for each participant, so the first participant finishes the contest at time t, the second — at time t + x, and so on. When a participant finishes the contest, their dissatisfaction equals to the number of participants that started the contest (or starting it now), but haven't yet finished it.
Determine the sum of dissatisfaction of all participants.
Input
The first line contains a single integer k (1 ≤ k ≤ 1000) — the number of test cases.
Each of the next k lines contains three integers n, x, t (1 ≤ n, x, t ≤ 2 ⋅ 10^9) — the number of participants, the start interval and the contest duration.
Output
Print k lines, in the i-th line print the total dissatisfaction of participants in the i-th test case.
Example
Input
4
4 2 5
3 1 2
3 3 10
2000000000 1 2000000000
Output
5
3
3
1999999999000000000
Note
In the first example the first participant starts at 0 and finishes at time 5. By that time the second and the third participants start, so the dissatisfaction of the first participant is 2.
The second participant starts at time 2 and finishes at time 7. By that time the third the fourth participants start, so the dissatisfaction of the second participant is 2.
The third participant starts at 4 and finishes at 9. By that time the fourth participant starts, so the dissatisfaction of the third participant is 1.
The fourth participant starts at 6 and finishes at 11. By time 11 everyone finishes the contest, so the dissatisfaction of the fourth participant is 0.
In the second example the first participant starts at 0 and finishes at time 2. By that time the second participants starts, and the third starts at exactly time 2. So the dissatisfaction of the first participant is 2.
The second participant starts at time 1 and finishes at time 3. At that time the third participant is solving the contest. | instruction | 0 | 63,389 | 17 | 126,778 |
Tags: combinatorics, geometry, greedy, math
Correct Solution:
```
from sys import stdin,stdout
import math, bisect, heapq
from collections import Counter, deque, defaultdict
L = lambda: list(map(int, stdin.readline().strip().split()))
I = lambda: int(stdin.readline().strip())
S = lambda: stdin.readline().strip()
C = lambda: stdin.readline().strip().split()
def pr(a): return("".join(list(map(str, a))))
#_________________________________________________#
def solve():
n,x,t = L()
m = min(n-1,t//x)
print(m*(n-m)+m*(m-1)//2)
for _ in range(I()):
solve()
``` | output | 1 | 63,389 | 17 | 126,779 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n people participating in some contest, they start participating in x minutes intervals. That means the first participant starts at time 0, the second participant starts at time x, the third — at time 2 ⋅ x, and so on.
Duration of contest is t minutes for each participant, so the first participant finishes the contest at time t, the second — at time t + x, and so on. When a participant finishes the contest, their dissatisfaction equals to the number of participants that started the contest (or starting it now), but haven't yet finished it.
Determine the sum of dissatisfaction of all participants.
Input
The first line contains a single integer k (1 ≤ k ≤ 1000) — the number of test cases.
Each of the next k lines contains three integers n, x, t (1 ≤ n, x, t ≤ 2 ⋅ 10^9) — the number of participants, the start interval and the contest duration.
Output
Print k lines, in the i-th line print the total dissatisfaction of participants in the i-th test case.
Example
Input
4
4 2 5
3 1 2
3 3 10
2000000000 1 2000000000
Output
5
3
3
1999999999000000000
Note
In the first example the first participant starts at 0 and finishes at time 5. By that time the second and the third participants start, so the dissatisfaction of the first participant is 2.
The second participant starts at time 2 and finishes at time 7. By that time the third the fourth participants start, so the dissatisfaction of the second participant is 2.
The third participant starts at 4 and finishes at 9. By that time the fourth participant starts, so the dissatisfaction of the third participant is 1.
The fourth participant starts at 6 and finishes at 11. By time 11 everyone finishes the contest, so the dissatisfaction of the fourth participant is 0.
In the second example the first participant starts at 0 and finishes at time 2. By that time the second participants starts, and the third starts at exactly time 2. So the dissatisfaction of the first participant is 2.
The second participant starts at time 1 and finishes at time 3. At that time the third participant is solving the contest. | instruction | 0 | 63,390 | 17 | 126,780 |
Tags: combinatorics, geometry, greedy, math
Correct Solution:
```
import os
import sys
from io import BytesIO, IOBase
from collections import Counter
import math as mt
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)
def gcd(a, b):
if a == 0:
return b
return gcd(b % a, a)
def lcm(a, b):
return (a * b) / gcd(a, b)
mod = int(1e9) + 7
def power(k, n):
if n == 0:
return 1
if n % 2:
return (power(k, n - 1) * k) % mod
t = power(k, n // 2)
return (t * t) % mod
def totalPrimeFactors(n):
count = 0
if (n % 2) == 0:
count += 1
while (n % 2) == 0:
n //= 2
i = 3
while i * i <= n:
if (n % i) == 0:
count += 1
while (n % i) == 0:
n //= i
i += 2
if n > 2:
count += 1
return count
# #MAXN = int(1e7 + 1)
# # spf = [0 for i in range(MAXN)]
#
#
# def sieve():
# spf[1] = 1
# for i in range(2, MAXN):
# spf[i] = i
# for i in range(4, MAXN, 2):
# spf[i] = 2
#
# for i in range(3, mt.ceil(mt.sqrt(MAXN))):
# if (spf[i] == i):
# for j in range(i * i, MAXN, i):
# if (spf[j] == j):
# spf[j] = i
#
#
# def getFactorization(x):
# ret = 0
# while (x != 1):
# k = spf[x]
# ret += 1
# # ret.add(spf[x])
# while x % k == 0:
# x //= k
#
# return ret
# Driver code
# precalculating Smallest Prime Factor
# sieve()
def main():
for _ in range(int(input())):
n, x, t= map(int, input().split())
m=t//x
if m<=n:
print((max(0, n-m))*m+m*(m-1)//2)
else:
print(n*(n-1)//2)
# = int(input())
# = list(map(int, input().split()))
# = input()
return
if __name__ == "__main__":
main()
``` | output | 1 | 63,390 | 17 | 126,781 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n people participating in some contest, they start participating in x minutes intervals. That means the first participant starts at time 0, the second participant starts at time x, the third — at time 2 ⋅ x, and so on.
Duration of contest is t minutes for each participant, so the first participant finishes the contest at time t, the second — at time t + x, and so on. When a participant finishes the contest, their dissatisfaction equals to the number of participants that started the contest (or starting it now), but haven't yet finished it.
Determine the sum of dissatisfaction of all participants.
Input
The first line contains a single integer k (1 ≤ k ≤ 1000) — the number of test cases.
Each of the next k lines contains three integers n, x, t (1 ≤ n, x, t ≤ 2 ⋅ 10^9) — the number of participants, the start interval and the contest duration.
Output
Print k lines, in the i-th line print the total dissatisfaction of participants in the i-th test case.
Example
Input
4
4 2 5
3 1 2
3 3 10
2000000000 1 2000000000
Output
5
3
3
1999999999000000000
Note
In the first example the first participant starts at 0 and finishes at time 5. By that time the second and the third participants start, so the dissatisfaction of the first participant is 2.
The second participant starts at time 2 and finishes at time 7. By that time the third the fourth participants start, so the dissatisfaction of the second participant is 2.
The third participant starts at 4 and finishes at 9. By that time the fourth participant starts, so the dissatisfaction of the third participant is 1.
The fourth participant starts at 6 and finishes at 11. By time 11 everyone finishes the contest, so the dissatisfaction of the fourth participant is 0.
In the second example the first participant starts at 0 and finishes at time 2. By that time the second participants starts, and the third starts at exactly time 2. So the dissatisfaction of the first participant is 2.
The second participant starts at time 1 and finishes at time 3. At that time the third participant is solving the contest. | instruction | 0 | 63,391 | 17 | 126,782 |
Tags: combinatorics, geometry, greedy, math
Correct Solution:
```
t=int(input())
for i in range(t):
n,x,k=map(int,input().split(' '))
dv=k//x
if n<=dv:
cnt=n*(n-1)//2
print(cnt)
else:
cnt=(n-dv)*dv
cnt+=dv*(dv-1)//2
print(cnt)
``` | output | 1 | 63,391 | 17 | 126,783 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n people participating in some contest, they start participating in x minutes intervals. That means the first participant starts at time 0, the second participant starts at time x, the third — at time 2 ⋅ x, and so on.
Duration of contest is t minutes for each participant, so the first participant finishes the contest at time t, the second — at time t + x, and so on. When a participant finishes the contest, their dissatisfaction equals to the number of participants that started the contest (or starting it now), but haven't yet finished it.
Determine the sum of dissatisfaction of all participants.
Input
The first line contains a single integer k (1 ≤ k ≤ 1000) — the number of test cases.
Each of the next k lines contains three integers n, x, t (1 ≤ n, x, t ≤ 2 ⋅ 10^9) — the number of participants, the start interval and the contest duration.
Output
Print k lines, in the i-th line print the total dissatisfaction of participants in the i-th test case.
Example
Input
4
4 2 5
3 1 2
3 3 10
2000000000 1 2000000000
Output
5
3
3
1999999999000000000
Note
In the first example the first participant starts at 0 and finishes at time 5. By that time the second and the third participants start, so the dissatisfaction of the first participant is 2.
The second participant starts at time 2 and finishes at time 7. By that time the third the fourth participants start, so the dissatisfaction of the second participant is 2.
The third participant starts at 4 and finishes at 9. By that time the fourth participant starts, so the dissatisfaction of the third participant is 1.
The fourth participant starts at 6 and finishes at 11. By time 11 everyone finishes the contest, so the dissatisfaction of the fourth participant is 0.
In the second example the first participant starts at 0 and finishes at time 2. By that time the second participants starts, and the third starts at exactly time 2. So the dissatisfaction of the first participant is 2.
The second participant starts at time 1 and finishes at time 3. At that time the third participant is solving the contest. | instruction | 0 | 63,392 | 17 | 126,784 |
Tags: combinatorics, geometry, greedy, math
Correct Solution:
```
for _ in range(int(input())):
n,x,t = map(int,input().split())
ans = max(0,n - t//x)*(t//x) + min(n - 1,(t//x) - 1)*min(n,t//x)//2
print(ans)
``` | output | 1 | 63,392 | 17 | 126,785 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n people participating in some contest, they start participating in x minutes intervals. That means the first participant starts at time 0, the second participant starts at time x, the third — at time 2 ⋅ x, and so on.
Duration of contest is t minutes for each participant, so the first participant finishes the contest at time t, the second — at time t + x, and so on. When a participant finishes the contest, their dissatisfaction equals to the number of participants that started the contest (or starting it now), but haven't yet finished it.
Determine the sum of dissatisfaction of all participants.
Input
The first line contains a single integer k (1 ≤ k ≤ 1000) — the number of test cases.
Each of the next k lines contains three integers n, x, t (1 ≤ n, x, t ≤ 2 ⋅ 10^9) — the number of participants, the start interval and the contest duration.
Output
Print k lines, in the i-th line print the total dissatisfaction of participants in the i-th test case.
Example
Input
4
4 2 5
3 1 2
3 3 10
2000000000 1 2000000000
Output
5
3
3
1999999999000000000
Note
In the first example the first participant starts at 0 and finishes at time 5. By that time the second and the third participants start, so the dissatisfaction of the first participant is 2.
The second participant starts at time 2 and finishes at time 7. By that time the third the fourth participants start, so the dissatisfaction of the second participant is 2.
The third participant starts at 4 and finishes at 9. By that time the fourth participant starts, so the dissatisfaction of the third participant is 1.
The fourth participant starts at 6 and finishes at 11. By time 11 everyone finishes the contest, so the dissatisfaction of the fourth participant is 0.
In the second example the first participant starts at 0 and finishes at time 2. By that time the second participants starts, and the third starts at exactly time 2. So the dissatisfaction of the first participant is 2.
The second participant starts at time 1 and finishes at time 3. At that time the third participant is solving the contest. | instruction | 0 | 63,393 | 17 | 126,786 |
Tags: combinatorics, geometry, greedy, math
Correct Solution:
```
t=int(input())
for i in range(t):
n,x,t=map(int,input().split())
if n==1:
print(0)
elif t<x:
print(0)
elif t==x:
print(n-1)
else:
ans=0
a=min(n-1,t//x)
ans+=(n-a)*a
f=a
f-=1
ans+=(f*(f+1))//2
print(ans)
``` | output | 1 | 63,393 | 17 | 126,787 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You still have partial information about the score during the historic football match. You are given a set of pairs (a_i, b_i), indicating that at some point during the match the score was "a_i: b_i". It is known that if the current score is «x:y», then after the goal it will change to "x+1:y" or "x:y+1". What is the largest number of times a draw could appear on the scoreboard?
The pairs "a_i:b_i" are given in chronological order (time increases), but you are given score only for some moments of time. The last pair corresponds to the end of the match.
Input
The first line contains a single integer n (1 ≤ n ≤ 10000) — the number of known moments in the match.
Each of the next n lines contains integers a_i and b_i (0 ≤ a_i, b_i ≤ 10^9), denoting the score of the match at that moment (that is, the number of goals by the first team and the number of goals by the second team).
All moments are given in chronological order, that is, sequences x_i and y_j are non-decreasing. The last score denotes the final result of the match.
Output
Print the maximum number of moments of time, during which the score was a draw. The starting moment of the match (with a score 0:0) is also counted.
Examples
Input
3
2 0
3 1
3 4
Output
2
Input
3
0 0
0 0
0 0
Output
1
Input
1
5 4
Output
5
Note
In the example one of the possible score sequences leading to the maximum number of draws is as follows: 0:0, 1:0, 2:0, 2:1, 3:1, 3:2, 3:3, 3:4. | instruction | 0 | 64,016 | 17 | 128,032 |
Tags: greedy, implementation
Correct Solution:
```
n = int(input())
o_x,o_y = map(int,input().split())
ties = min(o_x,o_y)+1
# print('init = ',ties)
for _ in range(n-1):
if o_x == o_y:
ties-=1
x,y = map(int,input().split())
if (x == o_x and y == o_y):
if x==y:
ties+=1
continue
# print('-->',min(x,y)-max(o_x,o_y)+1)
ties+=min(x,y)-max(o_x,o_y)+1 if min(x,y)-max(o_x,o_y)+1>0 else 0
# print('ties = ',ties)
o_x = x
o_y = y
print(ties)
``` | output | 1 | 64,016 | 17 | 128,033 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You still have partial information about the score during the historic football match. You are given a set of pairs (a_i, b_i), indicating that at some point during the match the score was "a_i: b_i". It is known that if the current score is «x:y», then after the goal it will change to "x+1:y" or "x:y+1". What is the largest number of times a draw could appear on the scoreboard?
The pairs "a_i:b_i" are given in chronological order (time increases), but you are given score only for some moments of time. The last pair corresponds to the end of the match.
Input
The first line contains a single integer n (1 ≤ n ≤ 10000) — the number of known moments in the match.
Each of the next n lines contains integers a_i and b_i (0 ≤ a_i, b_i ≤ 10^9), denoting the score of the match at that moment (that is, the number of goals by the first team and the number of goals by the second team).
All moments are given in chronological order, that is, sequences x_i and y_j are non-decreasing. The last score denotes the final result of the match.
Output
Print the maximum number of moments of time, during which the score was a draw. The starting moment of the match (with a score 0:0) is also counted.
Examples
Input
3
2 0
3 1
3 4
Output
2
Input
3
0 0
0 0
0 0
Output
1
Input
1
5 4
Output
5
Note
In the example one of the possible score sequences leading to the maximum number of draws is as follows: 0:0, 1:0, 2:0, 2:1, 3:1, 3:2, 3:3, 3:4. | instruction | 0 | 64,017 | 17 | 128,034 |
Tags: greedy, implementation
Correct Solution:
```
x , y , r = 0 , 0 , 1
for _ in range(int(input())):
a , b = map(int , input().split())
r += max(0 , min(a , b) - max(x , y) + (x != y))
x , y = a , b
print(r)
``` | output | 1 | 64,017 | 17 | 128,035 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You still have partial information about the score during the historic football match. You are given a set of pairs (a_i, b_i), indicating that at some point during the match the score was "a_i: b_i". It is known that if the current score is «x:y», then after the goal it will change to "x+1:y" or "x:y+1". What is the largest number of times a draw could appear on the scoreboard?
The pairs "a_i:b_i" are given in chronological order (time increases), but you are given score only for some moments of time. The last pair corresponds to the end of the match.
Input
The first line contains a single integer n (1 ≤ n ≤ 10000) — the number of known moments in the match.
Each of the next n lines contains integers a_i and b_i (0 ≤ a_i, b_i ≤ 10^9), denoting the score of the match at that moment (that is, the number of goals by the first team and the number of goals by the second team).
All moments are given in chronological order, that is, sequences x_i and y_j are non-decreasing. The last score denotes the final result of the match.
Output
Print the maximum number of moments of time, during which the score was a draw. The starting moment of the match (with a score 0:0) is also counted.
Examples
Input
3
2 0
3 1
3 4
Output
2
Input
3
0 0
0 0
0 0
Output
1
Input
1
5 4
Output
5
Note
In the example one of the possible score sequences leading to the maximum number of draws is as follows: 0:0, 1:0, 2:0, 2:1, 3:1, 3:2, 3:3, 3:4. | instruction | 0 | 64,018 | 17 | 128,036 |
Tags: greedy, implementation
Correct Solution:
```
def isdraw(x,y):
return x==y
def drawb(x,y,x1,y1):
if (x==x1 and y==y1):
return 0
if (x>=y and x1>=y1) or (x<=y and x1<=y1):
y,x=min(x,y),max(x,y)
y1,x1=min(x1,y1),max(x1,y1)
if y1>=x:
return 1+y1-x-isdraw(x,y)
else:
return 0
else:
return 1+min(x1,y1)-max(x,y)-isdraw(x,y)
ll=lambda:list(map(int,input().split()))
n=int(input())
d=1
x,y=0,0
for i in range(n):
[x1,y1]=ll()
# print(x,y,x1,y1,drawb(x,y,x1,y1))
d+=drawb(x,y,x1,y1)
x,y=x1,y1
print(d)
``` | output | 1 | 64,018 | 17 | 128,037 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You still have partial information about the score during the historic football match. You are given a set of pairs (a_i, b_i), indicating that at some point during the match the score was "a_i: b_i". It is known that if the current score is «x:y», then after the goal it will change to "x+1:y" or "x:y+1". What is the largest number of times a draw could appear on the scoreboard?
The pairs "a_i:b_i" are given in chronological order (time increases), but you are given score only for some moments of time. The last pair corresponds to the end of the match.
Input
The first line contains a single integer n (1 ≤ n ≤ 10000) — the number of known moments in the match.
Each of the next n lines contains integers a_i and b_i (0 ≤ a_i, b_i ≤ 10^9), denoting the score of the match at that moment (that is, the number of goals by the first team and the number of goals by the second team).
All moments are given in chronological order, that is, sequences x_i and y_j are non-decreasing. The last score denotes the final result of the match.
Output
Print the maximum number of moments of time, during which the score was a draw. The starting moment of the match (with a score 0:0) is also counted.
Examples
Input
3
2 0
3 1
3 4
Output
2
Input
3
0 0
0 0
0 0
Output
1
Input
1
5 4
Output
5
Note
In the example one of the possible score sequences leading to the maximum number of draws is as follows: 0:0, 1:0, 2:0, 2:1, 3:1, 3:2, 3:3, 3:4. | instruction | 0 | 64,019 | 17 | 128,038 |
Tags: greedy, implementation
Correct Solution:
```
cnt=0
arr=[]
brr=[]
arr.append(0)
brr.append(0)
x=0;y=0;l=0
n=int(input())
for i in range(n):
a,b=list(map(int,input().split()))
if a==x and b==y:
continue
arr.append(a)
brr.append(b)
l+=1
x=a;y=b
for i in range(l):
a=max(arr[i],brr[i])
b=min(arr[i+1],brr[i+1]);
if a>b: continue
cnt+=(b-a+1)
if i>0 and arr[i]==brr[i]:
cnt-=1
print(max(1,cnt))
``` | output | 1 | 64,019 | 17 | 128,039 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You still have partial information about the score during the historic football match. You are given a set of pairs (a_i, b_i), indicating that at some point during the match the score was "a_i: b_i". It is known that if the current score is «x:y», then after the goal it will change to "x+1:y" or "x:y+1". What is the largest number of times a draw could appear on the scoreboard?
The pairs "a_i:b_i" are given in chronological order (time increases), but you are given score only for some moments of time. The last pair corresponds to the end of the match.
Input
The first line contains a single integer n (1 ≤ n ≤ 10000) — the number of known moments in the match.
Each of the next n lines contains integers a_i and b_i (0 ≤ a_i, b_i ≤ 10^9), denoting the score of the match at that moment (that is, the number of goals by the first team and the number of goals by the second team).
All moments are given in chronological order, that is, sequences x_i and y_j are non-decreasing. The last score denotes the final result of the match.
Output
Print the maximum number of moments of time, during which the score was a draw. The starting moment of the match (with a score 0:0) is also counted.
Examples
Input
3
2 0
3 1
3 4
Output
2
Input
3
0 0
0 0
0 0
Output
1
Input
1
5 4
Output
5
Note
In the example one of the possible score sequences leading to the maximum number of draws is as follows: 0:0, 1:0, 2:0, 2:1, 3:1, 3:2, 3:3, 3:4. | instruction | 0 | 64,020 | 17 | 128,040 |
Tags: greedy, implementation
Correct Solution:
```
n = int(input())
cnt = 0
ca, cb = -1, -1
for i in range(n):
a, b = map(int, input().split())
v = max(min(a, b) - max(ca, cb) + (1 if ca != cb else 0), 0)
cnt += v
#print(f"i = {i} v = {v}")
ca = a
cb = b
print(cnt)
``` | output | 1 | 64,020 | 17 | 128,041 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You still have partial information about the score during the historic football match. You are given a set of pairs (a_i, b_i), indicating that at some point during the match the score was "a_i: b_i". It is known that if the current score is «x:y», then after the goal it will change to "x+1:y" or "x:y+1". What is the largest number of times a draw could appear on the scoreboard?
The pairs "a_i:b_i" are given in chronological order (time increases), but you are given score only for some moments of time. The last pair corresponds to the end of the match.
Input
The first line contains a single integer n (1 ≤ n ≤ 10000) — the number of known moments in the match.
Each of the next n lines contains integers a_i and b_i (0 ≤ a_i, b_i ≤ 10^9), denoting the score of the match at that moment (that is, the number of goals by the first team and the number of goals by the second team).
All moments are given in chronological order, that is, sequences x_i and y_j are non-decreasing. The last score denotes the final result of the match.
Output
Print the maximum number of moments of time, during which the score was a draw. The starting moment of the match (with a score 0:0) is also counted.
Examples
Input
3
2 0
3 1
3 4
Output
2
Input
3
0 0
0 0
0 0
Output
1
Input
1
5 4
Output
5
Note
In the example one of the possible score sequences leading to the maximum number of draws is as follows: 0:0, 1:0, 2:0, 2:1, 3:1, 3:2, 3:3, 3:4. | instruction | 0 | 64,021 | 17 | 128,042 |
Tags: greedy, implementation
Correct Solution:
```
n=int(input())
ans=1
x,y=0,0
for i in range(n):
a,b=map(int,input().split())
if (x!=a or y!=b):
ans+=max(0,min(a,b)-(max(x,y)+(x==y))+1)
x=a
y=b
print(ans)
``` | output | 1 | 64,021 | 17 | 128,043 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.