message stringlengths 2 433k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 113 108k | cluster float64 12 12 | __index_level_0__ int64 226 217k |
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
A median in an array with the length of n is an element which occupies position number <image> after we sort the elements in the non-decreasing order (the array elements are numbered starting with 1). A median of an array (2, 6, 1, 2, 3) is the number 2, and a median of array (0, 96, 17, 23) — the number 17.
We define an expression <image> as the integer part of dividing number a by number b.
One day Vasya showed Petya an array consisting of n integers and suggested finding the array's median. Petya didn't even look at the array and said that it equals x. Petya is a very honest boy, so he decided to add several numbers to the given array so that the median of the resulting array would be equal to x.
Petya can add any integers from 1 to 105 to the array, including the same numbers. Of course, he can add nothing to the array. If a number is added multiple times, then we should consider it the number of times it occurs. It is not allowed to delete of change initial numbers of the array.
While Petya is busy distracting Vasya, your task is to find the minimum number of elements he will need.
Input
The first input line contains two space-separated integers n and x (1 ≤ n ≤ 500, 1 ≤ x ≤ 105) — the initial array's length and the required median's value. The second line contains n space-separated numbers — the initial array. The elements of the array are integers from 1 to 105. The array elements are not necessarily different.
Output
Print the only integer — the minimum number of elements Petya needs to add to the array so that its median equals x.
Examples
Input
3 10
10 20 30
Output
1
Input
3 4
1 2 3
Output
4
Note
In the first sample we can add number 9 to array (10, 20, 30). The resulting array (9, 10, 20, 30) will have a median in position <image>, that is, 10.
In the second sample you should add numbers 4, 5, 5, 5. The resulting array has median equal to 4. | instruction | 0 | 87,850 | 12 | 175,700 |
Tags: greedy, math, sortings
Correct Solution:
```
def main():
def m(a):
return (len(a) + 1) // 2 - 1
from bisect import insort
(n, x) = map(int, input().split(' '))
a = list(sorted(list(map(int, input().split(' ')))))
if x not in a:
insort(a, x)
while a[m(a)] != x:
if a[m(a)] < x:
a = a + [int(1e5)]
else:
a = [1] + a
return len(a) - n
print(main())
``` | output | 1 | 87,850 | 12 | 175,701 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A median in an array with the length of n is an element which occupies position number <image> after we sort the elements in the non-decreasing order (the array elements are numbered starting with 1). A median of an array (2, 6, 1, 2, 3) is the number 2, and a median of array (0, 96, 17, 23) — the number 17.
We define an expression <image> as the integer part of dividing number a by number b.
One day Vasya showed Petya an array consisting of n integers and suggested finding the array's median. Petya didn't even look at the array and said that it equals x. Petya is a very honest boy, so he decided to add several numbers to the given array so that the median of the resulting array would be equal to x.
Petya can add any integers from 1 to 105 to the array, including the same numbers. Of course, he can add nothing to the array. If a number is added multiple times, then we should consider it the number of times it occurs. It is not allowed to delete of change initial numbers of the array.
While Petya is busy distracting Vasya, your task is to find the minimum number of elements he will need.
Input
The first input line contains two space-separated integers n and x (1 ≤ n ≤ 500, 1 ≤ x ≤ 105) — the initial array's length and the required median's value. The second line contains n space-separated numbers — the initial array. The elements of the array are integers from 1 to 105. The array elements are not necessarily different.
Output
Print the only integer — the minimum number of elements Petya needs to add to the array so that its median equals x.
Examples
Input
3 10
10 20 30
Output
1
Input
3 4
1 2 3
Output
4
Note
In the first sample we can add number 9 to array (10, 20, 30). The resulting array (9, 10, 20, 30) will have a median in position <image>, that is, 10.
In the second sample you should add numbers 4, 5, 5, 5. The resulting array has median equal to 4. | instruction | 0 | 87,851 | 12 | 175,702 |
Tags: greedy, math, sortings
Correct Solution:
```
#Code by Sounak, IIESTS
#------------------------------warmup----------------------------
import os
import sys
import math
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
#-------------------game starts now-----------------------------------------------------
n,x=map(int,input().split())
a=list(map(int,input().split()))
s=set(a)
count=0
c=0
if x not in s:
n+=1
a.append(x)
count=1
c=1
a.sort()
e=math.floor((n+1)/2)
if a[e-1]!=x:
l=0
for i in range (n):
if a[i]==x:
l=i
r=n-l-1
if a[e]>x:
count+=r-l-1
else:
count+=l-r
r=0
for i in range (n-1,-1,-1):
if a[i]==x:
r=n-i-1
l=n-r-1
if a[e]>x:
c+=r-l-1
else:
c+=l-r
count=min(count,c)
print(count)
``` | output | 1 | 87,851 | 12 | 175,703 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A median in an array with the length of n is an element which occupies position number <image> after we sort the elements in the non-decreasing order (the array elements are numbered starting with 1). A median of an array (2, 6, 1, 2, 3) is the number 2, and a median of array (0, 96, 17, 23) — the number 17.
We define an expression <image> as the integer part of dividing number a by number b.
One day Vasya showed Petya an array consisting of n integers and suggested finding the array's median. Petya didn't even look at the array and said that it equals x. Petya is a very honest boy, so he decided to add several numbers to the given array so that the median of the resulting array would be equal to x.
Petya can add any integers from 1 to 105 to the array, including the same numbers. Of course, he can add nothing to the array. If a number is added multiple times, then we should consider it the number of times it occurs. It is not allowed to delete of change initial numbers of the array.
While Petya is busy distracting Vasya, your task is to find the minimum number of elements he will need.
Input
The first input line contains two space-separated integers n and x (1 ≤ n ≤ 500, 1 ≤ x ≤ 105) — the initial array's length and the required median's value. The second line contains n space-separated numbers — the initial array. The elements of the array are integers from 1 to 105. The array elements are not necessarily different.
Output
Print the only integer — the minimum number of elements Petya needs to add to the array so that its median equals x.
Examples
Input
3 10
10 20 30
Output
1
Input
3 4
1 2 3
Output
4
Note
In the first sample we can add number 9 to array (10, 20, 30). The resulting array (9, 10, 20, 30) will have a median in position <image>, that is, 10.
In the second sample you should add numbers 4, 5, 5, 5. The resulting array has median equal to 4. | instruction | 0 | 87,852 | 12 | 175,704 |
Tags: greedy, math, sortings
Correct Solution:
```
import sys
import bisect
input = lambda: sys.stdin.readline().strip("\r\n")
n, x = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
ans = 0
while a[(len(a)-1)//2] != x:
a.append(x)
a.sort()
ans += 1
print(ans)
``` | output | 1 | 87,852 | 12 | 175,705 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A median in an array with the length of n is an element which occupies position number <image> after we sort the elements in the non-decreasing order (the array elements are numbered starting with 1). A median of an array (2, 6, 1, 2, 3) is the number 2, and a median of array (0, 96, 17, 23) — the number 17.
We define an expression <image> as the integer part of dividing number a by number b.
One day Vasya showed Petya an array consisting of n integers and suggested finding the array's median. Petya didn't even look at the array and said that it equals x. Petya is a very honest boy, so he decided to add several numbers to the given array so that the median of the resulting array would be equal to x.
Petya can add any integers from 1 to 105 to the array, including the same numbers. Of course, he can add nothing to the array. If a number is added multiple times, then we should consider it the number of times it occurs. It is not allowed to delete of change initial numbers of the array.
While Petya is busy distracting Vasya, your task is to find the minimum number of elements he will need.
Input
The first input line contains two space-separated integers n and x (1 ≤ n ≤ 500, 1 ≤ x ≤ 105) — the initial array's length and the required median's value. The second line contains n space-separated numbers — the initial array. The elements of the array are integers from 1 to 105. The array elements are not necessarily different.
Output
Print the only integer — the minimum number of elements Petya needs to add to the array so that its median equals x.
Examples
Input
3 10
10 20 30
Output
1
Input
3 4
1 2 3
Output
4
Note
In the first sample we can add number 9 to array (10, 20, 30). The resulting array (9, 10, 20, 30) will have a median in position <image>, that is, 10.
In the second sample you should add numbers 4, 5, 5, 5. The resulting array has median equal to 4. | instruction | 0 | 87,853 | 12 | 175,706 |
Tags: greedy, math, sortings
Correct Solution:
```
import math
n,x=map(int,input().split())
a=list(map(int,input().split()))
new=0
if(a.count(x)==0):
a.append(x)
new+=1
a.sort()
index=0
dest=(n+1)//2
best=1000
val=0
n=len(a)
for i in range(n):
if(a[i]==x):
d=abs(dest-(i+1))
if(d<best):
best=d
val=i+1
n1=n
if(val<=(n+1)//2):
while(val!=(n1+1)//2):
val+=1
n1+=1
print(n1-n+new)
else:
while(val!=(n1+1)//2):
n1+=1
print(n1-n+new)
``` | output | 1 | 87,853 | 12 | 175,707 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A median in an array with the length of n is an element which occupies position number <image> after we sort the elements in the non-decreasing order (the array elements are numbered starting with 1). A median of an array (2, 6, 1, 2, 3) is the number 2, and a median of array (0, 96, 17, 23) — the number 17.
We define an expression <image> as the integer part of dividing number a by number b.
One day Vasya showed Petya an array consisting of n integers and suggested finding the array's median. Petya didn't even look at the array and said that it equals x. Petya is a very honest boy, so he decided to add several numbers to the given array so that the median of the resulting array would be equal to x.
Petya can add any integers from 1 to 105 to the array, including the same numbers. Of course, he can add nothing to the array. If a number is added multiple times, then we should consider it the number of times it occurs. It is not allowed to delete of change initial numbers of the array.
While Petya is busy distracting Vasya, your task is to find the minimum number of elements he will need.
Input
The first input line contains two space-separated integers n and x (1 ≤ n ≤ 500, 1 ≤ x ≤ 105) — the initial array's length and the required median's value. The second line contains n space-separated numbers — the initial array. The elements of the array are integers from 1 to 105. The array elements are not necessarily different.
Output
Print the only integer — the minimum number of elements Petya needs to add to the array so that its median equals x.
Examples
Input
3 10
10 20 30
Output
1
Input
3 4
1 2 3
Output
4
Note
In the first sample we can add number 9 to array (10, 20, 30). The resulting array (9, 10, 20, 30) will have a median in position <image>, that is, 10.
In the second sample you should add numbers 4, 5, 5, 5. The resulting array has median equal to 4. | instruction | 0 | 87,854 | 12 | 175,708 |
Tags: greedy, math, sortings
Correct Solution:
```
n,x = map(int,input().split())
a = [int(x) for x in input().split()]
ans = 0
if x not in a:
ans += 1
a.append(x)
a.sort()
n = len(a)
while x != a[(n+1)//2 - 1]:
if x < a[(n+1)//2 - 1]:
a.append(1)
a.sort()
ans+=1
else:
a.append(10**5)
ans+=1
n = len(a)
print(ans)
``` | output | 1 | 87,854 | 12 | 175,709 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A median in an array with the length of n is an element which occupies position number <image> after we sort the elements in the non-decreasing order (the array elements are numbered starting with 1). A median of an array (2, 6, 1, 2, 3) is the number 2, and a median of array (0, 96, 17, 23) — the number 17.
We define an expression <image> as the integer part of dividing number a by number b.
One day Vasya showed Petya an array consisting of n integers and suggested finding the array's median. Petya didn't even look at the array and said that it equals x. Petya is a very honest boy, so he decided to add several numbers to the given array so that the median of the resulting array would be equal to x.
Petya can add any integers from 1 to 105 to the array, including the same numbers. Of course, he can add nothing to the array. If a number is added multiple times, then we should consider it the number of times it occurs. It is not allowed to delete of change initial numbers of the array.
While Petya is busy distracting Vasya, your task is to find the minimum number of elements he will need.
Input
The first input line contains two space-separated integers n and x (1 ≤ n ≤ 500, 1 ≤ x ≤ 105) — the initial array's length and the required median's value. The second line contains n space-separated numbers — the initial array. The elements of the array are integers from 1 to 105. The array elements are not necessarily different.
Output
Print the only integer — the minimum number of elements Petya needs to add to the array so that its median equals x.
Examples
Input
3 10
10 20 30
Output
1
Input
3 4
1 2 3
Output
4
Note
In the first sample we can add number 9 to array (10, 20, 30). The resulting array (9, 10, 20, 30) will have a median in position <image>, that is, 10.
In the second sample you should add numbers 4, 5, 5, 5. The resulting array has median equal to 4. | instruction | 0 | 87,855 | 12 | 175,710 |
Tags: greedy, math, sortings
Correct Solution:
```
def median(n,m,li):
count = 0
while True:
li.sort()
if li[(n+1)//2 -1]== m:
return count
li.append(m)
n+=1
count+=1
n,m = input().split()
li = [int(x) for x in input().split()]
print(median(int(n),int(m),li))
``` | output | 1 | 87,855 | 12 | 175,711 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A median in an array with the length of n is an element which occupies position number <image> after we sort the elements in the non-decreasing order (the array elements are numbered starting with 1). A median of an array (2, 6, 1, 2, 3) is the number 2, and a median of array (0, 96, 17, 23) — the number 17.
We define an expression <image> as the integer part of dividing number a by number b.
One day Vasya showed Petya an array consisting of n integers and suggested finding the array's median. Petya didn't even look at the array and said that it equals x. Petya is a very honest boy, so he decided to add several numbers to the given array so that the median of the resulting array would be equal to x.
Petya can add any integers from 1 to 105 to the array, including the same numbers. Of course, he can add nothing to the array. If a number is added multiple times, then we should consider it the number of times it occurs. It is not allowed to delete of change initial numbers of the array.
While Petya is busy distracting Vasya, your task is to find the minimum number of elements he will need.
Input
The first input line contains two space-separated integers n and x (1 ≤ n ≤ 500, 1 ≤ x ≤ 105) — the initial array's length and the required median's value. The second line contains n space-separated numbers — the initial array. The elements of the array are integers from 1 to 105. The array elements are not necessarily different.
Output
Print the only integer — the minimum number of elements Petya needs to add to the array so that its median equals x.
Examples
Input
3 10
10 20 30
Output
1
Input
3 4
1 2 3
Output
4
Note
In the first sample we can add number 9 to array (10, 20, 30). The resulting array (9, 10, 20, 30) will have a median in position <image>, that is, 10.
In the second sample you should add numbers 4, 5, 5, 5. The resulting array has median equal to 4. | instruction | 0 | 87,856 | 12 | 175,712 |
Tags: greedy, math, sortings
Correct Solution:
```
import bisect
I=lambda:map(int,input().split())
n,x=I()
a,s=sorted(I()),0
while a[(n-1)//2]!=x:
a.insert(bisect.bisect_right(a,x),x)
s+=1
n+=1
print(s)
``` | output | 1 | 87,856 | 12 | 175,713 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A median in an array with the length of n is an element which occupies position number <image> after we sort the elements in the non-decreasing order (the array elements are numbered starting with 1). A median of an array (2, 6, 1, 2, 3) is the number 2, and a median of array (0, 96, 17, 23) — the number 17.
We define an expression <image> as the integer part of dividing number a by number b.
One day Vasya showed Petya an array consisting of n integers and suggested finding the array's median. Petya didn't even look at the array and said that it equals x. Petya is a very honest boy, so he decided to add several numbers to the given array so that the median of the resulting array would be equal to x.
Petya can add any integers from 1 to 105 to the array, including the same numbers. Of course, he can add nothing to the array. If a number is added multiple times, then we should consider it the number of times it occurs. It is not allowed to delete of change initial numbers of the array.
While Petya is busy distracting Vasya, your task is to find the minimum number of elements he will need.
Input
The first input line contains two space-separated integers n and x (1 ≤ n ≤ 500, 1 ≤ x ≤ 105) — the initial array's length and the required median's value. The second line contains n space-separated numbers — the initial array. The elements of the array are integers from 1 to 105. The array elements are not necessarily different.
Output
Print the only integer — the minimum number of elements Petya needs to add to the array so that its median equals x.
Examples
Input
3 10
10 20 30
Output
1
Input
3 4
1 2 3
Output
4
Note
In the first sample we can add number 9 to array (10, 20, 30). The resulting array (9, 10, 20, 30) will have a median in position <image>, that is, 10.
In the second sample you should add numbers 4, 5, 5, 5. The resulting array has median equal to 4.
Submitted Solution:
```
import bisect
n,x = map(int,input().split())
a = sorted(map(int,input().split()))
ans = 0
if a[(n-1)//2] != x:
while a[(n-1)//2] != x:
a.insert(bisect.bisect_right(a,x),x)
ans+=1
n+=1
print(ans)
``` | instruction | 0 | 87,857 | 12 | 175,714 |
Yes | output | 1 | 87,857 | 12 | 175,715 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A median in an array with the length of n is an element which occupies position number <image> after we sort the elements in the non-decreasing order (the array elements are numbered starting with 1). A median of an array (2, 6, 1, 2, 3) is the number 2, and a median of array (0, 96, 17, 23) — the number 17.
We define an expression <image> as the integer part of dividing number a by number b.
One day Vasya showed Petya an array consisting of n integers and suggested finding the array's median. Petya didn't even look at the array and said that it equals x. Petya is a very honest boy, so he decided to add several numbers to the given array so that the median of the resulting array would be equal to x.
Petya can add any integers from 1 to 105 to the array, including the same numbers. Of course, he can add nothing to the array. If a number is added multiple times, then we should consider it the number of times it occurs. It is not allowed to delete of change initial numbers of the array.
While Petya is busy distracting Vasya, your task is to find the minimum number of elements he will need.
Input
The first input line contains two space-separated integers n and x (1 ≤ n ≤ 500, 1 ≤ x ≤ 105) — the initial array's length and the required median's value. The second line contains n space-separated numbers — the initial array. The elements of the array are integers from 1 to 105. The array elements are not necessarily different.
Output
Print the only integer — the minimum number of elements Petya needs to add to the array so that its median equals x.
Examples
Input
3 10
10 20 30
Output
1
Input
3 4
1 2 3
Output
4
Note
In the first sample we can add number 9 to array (10, 20, 30). The resulting array (9, 10, 20, 30) will have a median in position <image>, that is, 10.
In the second sample you should add numbers 4, 5, 5, 5. The resulting array has median equal to 4.
Submitted Solution:
```
n, x = map(int, input().split())
a = list(map(int, input().split()))
ans = 0
if (x not in a):
a.append(x)
ans += 1
n += 1
a.sort()
index = 0
middle = (n + 1) // 2
close_dist = n
for i in range(n):
if (a[i] == x):
dist = abs((i + 1) - middle)
if (dist < close_dist):
index = i + 1
close_dist = dist
front = n - index
behind = index - 1
ans += abs(front - behind - int(front > behind))
print (ans)
``` | instruction | 0 | 87,858 | 12 | 175,716 |
Yes | output | 1 | 87,858 | 12 | 175,717 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A median in an array with the length of n is an element which occupies position number <image> after we sort the elements in the non-decreasing order (the array elements are numbered starting with 1). A median of an array (2, 6, 1, 2, 3) is the number 2, and a median of array (0, 96, 17, 23) — the number 17.
We define an expression <image> as the integer part of dividing number a by number b.
One day Vasya showed Petya an array consisting of n integers and suggested finding the array's median. Petya didn't even look at the array and said that it equals x. Petya is a very honest boy, so he decided to add several numbers to the given array so that the median of the resulting array would be equal to x.
Petya can add any integers from 1 to 105 to the array, including the same numbers. Of course, he can add nothing to the array. If a number is added multiple times, then we should consider it the number of times it occurs. It is not allowed to delete of change initial numbers of the array.
While Petya is busy distracting Vasya, your task is to find the minimum number of elements he will need.
Input
The first input line contains two space-separated integers n and x (1 ≤ n ≤ 500, 1 ≤ x ≤ 105) — the initial array's length and the required median's value. The second line contains n space-separated numbers — the initial array. The elements of the array are integers from 1 to 105. The array elements are not necessarily different.
Output
Print the only integer — the minimum number of elements Petya needs to add to the array so that its median equals x.
Examples
Input
3 10
10 20 30
Output
1
Input
3 4
1 2 3
Output
4
Note
In the first sample we can add number 9 to array (10, 20, 30). The resulting array (9, 10, 20, 30) will have a median in position <image>, that is, 10.
In the second sample you should add numbers 4, 5, 5, 5. The resulting array has median equal to 4.
Submitted Solution:
```
n, x = (int(x) for x in input().split())
lt, eq, gt, val = 0, 0, 0, 0
for ai in (int(x) for x in input().split()):
if ai < x:
lt += 1
elif ai == x:
eq += 1
else:
gt += 1
if eq == 0:
val = eq = 1
if gt >= lt + eq:
val += gt - (lt + eq)
else:
val += max(0, (lt * 2 + 1) - (n + val))
print(val)
``` | instruction | 0 | 87,859 | 12 | 175,718 |
Yes | output | 1 | 87,859 | 12 | 175,719 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A median in an array with the length of n is an element which occupies position number <image> after we sort the elements in the non-decreasing order (the array elements are numbered starting with 1). A median of an array (2, 6, 1, 2, 3) is the number 2, and a median of array (0, 96, 17, 23) — the number 17.
We define an expression <image> as the integer part of dividing number a by number b.
One day Vasya showed Petya an array consisting of n integers and suggested finding the array's median. Petya didn't even look at the array and said that it equals x. Petya is a very honest boy, so he decided to add several numbers to the given array so that the median of the resulting array would be equal to x.
Petya can add any integers from 1 to 105 to the array, including the same numbers. Of course, he can add nothing to the array. If a number is added multiple times, then we should consider it the number of times it occurs. It is not allowed to delete of change initial numbers of the array.
While Petya is busy distracting Vasya, your task is to find the minimum number of elements he will need.
Input
The first input line contains two space-separated integers n and x (1 ≤ n ≤ 500, 1 ≤ x ≤ 105) — the initial array's length and the required median's value. The second line contains n space-separated numbers — the initial array. The elements of the array are integers from 1 to 105. The array elements are not necessarily different.
Output
Print the only integer — the minimum number of elements Petya needs to add to the array so that its median equals x.
Examples
Input
3 10
10 20 30
Output
1
Input
3 4
1 2 3
Output
4
Note
In the first sample we can add number 9 to array (10, 20, 30). The resulting array (9, 10, 20, 30) will have a median in position <image>, that is, 10.
In the second sample you should add numbers 4, 5, 5, 5. The resulting array has median equal to 4.
Submitted Solution:
```
from bisect import bisect_left as bl
n,x=map(int,input().split())
cnt=0
l=[int(i) for i in input().split()]
l.sort()
med=l[n//2-(1-n%2)]
if med==x:
print(0)
exit()
if x not in l:
l.append(x)
cnt=1
l.sort()
def is_not_x(l):
# print(l)
#print(l)
length=len(l)
if length%2:
ind=length//2
else:
ind=length//2-1
return l[ind]!=x
while is_not_x(l):
med=l[len(l)//2-(1-len(l)%2)]
if med<x:
karma="add"
else:
karma="remove"
if karma=="add":
z=10**5
l.append(z)
else:
l.insert(0,1)
cnt+=1
print(cnt)
``` | instruction | 0 | 87,860 | 12 | 175,720 |
Yes | output | 1 | 87,860 | 12 | 175,721 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A median in an array with the length of n is an element which occupies position number <image> after we sort the elements in the non-decreasing order (the array elements are numbered starting with 1). A median of an array (2, 6, 1, 2, 3) is the number 2, and a median of array (0, 96, 17, 23) — the number 17.
We define an expression <image> as the integer part of dividing number a by number b.
One day Vasya showed Petya an array consisting of n integers and suggested finding the array's median. Petya didn't even look at the array and said that it equals x. Petya is a very honest boy, so he decided to add several numbers to the given array so that the median of the resulting array would be equal to x.
Petya can add any integers from 1 to 105 to the array, including the same numbers. Of course, he can add nothing to the array. If a number is added multiple times, then we should consider it the number of times it occurs. It is not allowed to delete of change initial numbers of the array.
While Petya is busy distracting Vasya, your task is to find the minimum number of elements he will need.
Input
The first input line contains two space-separated integers n and x (1 ≤ n ≤ 500, 1 ≤ x ≤ 105) — the initial array's length and the required median's value. The second line contains n space-separated numbers — the initial array. The elements of the array are integers from 1 to 105. The array elements are not necessarily different.
Output
Print the only integer — the minimum number of elements Petya needs to add to the array so that its median equals x.
Examples
Input
3 10
10 20 30
Output
1
Input
3 4
1 2 3
Output
4
Note
In the first sample we can add number 9 to array (10, 20, 30). The resulting array (9, 10, 20, 30) will have a median in position <image>, that is, 10.
In the second sample you should add numbers 4, 5, 5, 5. The resulting array has median equal to 4.
Submitted Solution:
```
# Problem: C. Median
# Contest: Codeforces - Codeforces Round #113 (Div. 2)
# URL: https://codeforces.com/problemset/problem/166/C
# Memory Limit: 256 MB
# Time Limit: 2000 ms
#
# KAPOOR'S
from sys import stdin, stdout
def INI():
return int(stdin.readline())
def INL():
return [int(_) for _ in stdin.readline().split()]
def INS():
return stdin.readline()
def MOD():
return pow(10,9)+7
def OPS(ans):
stdout.write(str(ans)+"\n")
def OPL(ans):
[stdout.write(str(_)+" ") for _ in ans]
stdout.write("\n")
from bisect import bisect_left
if __name__=="__main__":
n,x=INL()
X=sorted(INL())
m=(n-1)//2
ans=0
if X[m]<x:
for _ in range(m,n):
if X[_]==x:
i=_
break
else:
i=n
ans+=2*(i-m)
if n%2==0:
ans-=1
elif x<X[m]:
for _ in range(m,-1,-1):
if X[_]==x:
i=_
break
else:
i=-1
ans+=2*(m-i)
if n%2==1:
ans-=1
OPS(ans)
``` | instruction | 0 | 87,861 | 12 | 175,722 |
No | output | 1 | 87,861 | 12 | 175,723 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A median in an array with the length of n is an element which occupies position number <image> after we sort the elements in the non-decreasing order (the array elements are numbered starting with 1). A median of an array (2, 6, 1, 2, 3) is the number 2, and a median of array (0, 96, 17, 23) — the number 17.
We define an expression <image> as the integer part of dividing number a by number b.
One day Vasya showed Petya an array consisting of n integers and suggested finding the array's median. Petya didn't even look at the array and said that it equals x. Petya is a very honest boy, so he decided to add several numbers to the given array so that the median of the resulting array would be equal to x.
Petya can add any integers from 1 to 105 to the array, including the same numbers. Of course, he can add nothing to the array. If a number is added multiple times, then we should consider it the number of times it occurs. It is not allowed to delete of change initial numbers of the array.
While Petya is busy distracting Vasya, your task is to find the minimum number of elements he will need.
Input
The first input line contains two space-separated integers n and x (1 ≤ n ≤ 500, 1 ≤ x ≤ 105) — the initial array's length and the required median's value. The second line contains n space-separated numbers — the initial array. The elements of the array are integers from 1 to 105. The array elements are not necessarily different.
Output
Print the only integer — the minimum number of elements Petya needs to add to the array so that its median equals x.
Examples
Input
3 10
10 20 30
Output
1
Input
3 4
1 2 3
Output
4
Note
In the first sample we can add number 9 to array (10, 20, 30). The resulting array (9, 10, 20, 30) will have a median in position <image>, that is, 10.
In the second sample you should add numbers 4, 5, 5, 5. The resulting array has median equal to 4.
Submitted Solution:
```
import sys
if __name__ == '__main__':
#reading input
total, required_median = [int(n) for n in input().split()]
numbers = [int(n) for n in input().split()]
#---------------
bigger = 0 #number of nums that are bigger than the given median
smaller = 0 #number of nums that are smaller than the given median
same = 0 #number of nums that are equal to the given median
found = 0 #flag that shows if expected median was found in initial list. Turns to 1 if found
numbers_to_add = 0 #result to be output
#iterate through the list of numbers we have
for num in numbers:
if num > required_median:
bigger += 1
elif num < required_median:
smaller += 1
elif num == required_median:
same += 1
if same == 0: #if no same was found ... we add one therefore adding it to ...
numbers_to_add += 1 #... the output
total += 1 #... and the total number of elements in our list
else:
same -= 1 #we remove that element from the number of "same" because this will be our median
diff = abs(bigger - smaller) #we calculate the difference we have between the number of nums bigger and smaller than median
if bigger > smaller: #if we have more bigger elements than smaller
smaller = smaller + min(same, diff) #we will consider the equal elements that we have to be part of the smaller
same = same - min(same, diff) #we naturally subtract the number we got from the equal
to_add = 0
if bigger > smaller: #if bigger is still bigger than smaller
to_add = (bigger - smaller - 1) #I noticed that if the bigger == smaller - 1 AND the total is even, the solution stands. Since this will require the minimum number of moves we will see if this will give a solution.
if (total + to_add)%2 == 0: #we check if we add that amount we will get an even total
numbers_to_add += to_add #we add the number if that's the case
else:
numbers_to_add += to_add + 1 #if it's odd we will have to add one more element to what we already wanted to add
#same logic here
elif bigger < smaller:
bigger = bigger + min(same, diff)
same = same - min(same, diff)
to_add = (smaller - bigger)
if (total + to_add) % 2 != 0:
numbers_to_add += to_add
else:
numbers_to_add += to_add - 1
print(numbers_to_add)
``` | instruction | 0 | 87,862 | 12 | 175,724 |
No | output | 1 | 87,862 | 12 | 175,725 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A median in an array with the length of n is an element which occupies position number <image> after we sort the elements in the non-decreasing order (the array elements are numbered starting with 1). A median of an array (2, 6, 1, 2, 3) is the number 2, and a median of array (0, 96, 17, 23) — the number 17.
We define an expression <image> as the integer part of dividing number a by number b.
One day Vasya showed Petya an array consisting of n integers and suggested finding the array's median. Petya didn't even look at the array and said that it equals x. Petya is a very honest boy, so he decided to add several numbers to the given array so that the median of the resulting array would be equal to x.
Petya can add any integers from 1 to 105 to the array, including the same numbers. Of course, he can add nothing to the array. If a number is added multiple times, then we should consider it the number of times it occurs. It is not allowed to delete of change initial numbers of the array.
While Petya is busy distracting Vasya, your task is to find the minimum number of elements he will need.
Input
The first input line contains two space-separated integers n and x (1 ≤ n ≤ 500, 1 ≤ x ≤ 105) — the initial array's length and the required median's value. The second line contains n space-separated numbers — the initial array. The elements of the array are integers from 1 to 105. The array elements are not necessarily different.
Output
Print the only integer — the minimum number of elements Petya needs to add to the array so that its median equals x.
Examples
Input
3 10
10 20 30
Output
1
Input
3 4
1 2 3
Output
4
Note
In the first sample we can add number 9 to array (10, 20, 30). The resulting array (9, 10, 20, 30) will have a median in position <image>, that is, 10.
In the second sample you should add numbers 4, 5, 5, 5. The resulting array has median equal to 4.
Submitted Solution:
```
from bisect import bisect_left
n, x = list(map(int, input().split()))
arr = list(map(int, input().split()))
ans = 0
arr.sort()
ind = bisect_left(arr, x)
if ind == n:
ans = n + 1
elif ind == 0:
if arr[0] == x:
ans = max(0, n - 2)
else:
ans = n
else:
if arr[ind] == x:
if ind != (n+1)//2:
ans = abs(2*ind - n - 2)
else:
if ind != (n+1)//2:
if ind < (n+1)//2:
ans += abs((n+1)//2 - ind)*2 + 1
else:
ans += abs(2*ind - n - 2) + 1
else:
ans = 1
print(ans)
``` | instruction | 0 | 87,863 | 12 | 175,726 |
No | output | 1 | 87,863 | 12 | 175,727 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A median in an array with the length of n is an element which occupies position number <image> after we sort the elements in the non-decreasing order (the array elements are numbered starting with 1). A median of an array (2, 6, 1, 2, 3) is the number 2, and a median of array (0, 96, 17, 23) — the number 17.
We define an expression <image> as the integer part of dividing number a by number b.
One day Vasya showed Petya an array consisting of n integers and suggested finding the array's median. Petya didn't even look at the array and said that it equals x. Petya is a very honest boy, so he decided to add several numbers to the given array so that the median of the resulting array would be equal to x.
Petya can add any integers from 1 to 105 to the array, including the same numbers. Of course, he can add nothing to the array. If a number is added multiple times, then we should consider it the number of times it occurs. It is not allowed to delete of change initial numbers of the array.
While Petya is busy distracting Vasya, your task is to find the minimum number of elements he will need.
Input
The first input line contains two space-separated integers n and x (1 ≤ n ≤ 500, 1 ≤ x ≤ 105) — the initial array's length and the required median's value. The second line contains n space-separated numbers — the initial array. The elements of the array are integers from 1 to 105. The array elements are not necessarily different.
Output
Print the only integer — the minimum number of elements Petya needs to add to the array so that its median equals x.
Examples
Input
3 10
10 20 30
Output
1
Input
3 4
1 2 3
Output
4
Note
In the first sample we can add number 9 to array (10, 20, 30). The resulting array (9, 10, 20, 30) will have a median in position <image>, that is, 10.
In the second sample you should add numbers 4, 5, 5, 5. The resulting array has median equal to 4.
Submitted Solution:
```
n,x = map(int,input().split())
a = [int(x) for x in input().split()]
a.sort()
k = 0
if x not in a:
if x > a[n-1] or x < a[0]:
print(n+1)
else:
for i in reversed(range(n)):
if a[i]<x:
k = i
break
if k + 1 == (n+2)//2:
print(1)
elif k + 1 > (n+1)//2:
print(k+1)
else:
print(n-(k+2))
else:
j = a.index(x)
if x == a[(n+1)//2]:
print(0)
if j < (n+1)//2:
print((n+1)//2 - (j+1))
else:
print(2*(j+1) - 1 - n)
``` | instruction | 0 | 87,864 | 12 | 175,728 |
No | output | 1 | 87,864 | 12 | 175,729 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ivan has got an array of n non-negative integers a1, a2, ..., an. Ivan knows that the array is sorted in the non-decreasing order.
Ivan wrote out integers 2a1, 2a2, ..., 2an on a piece of paper. Now he wonders, what minimum number of integers of form 2b (b ≥ 0) need to be added to the piece of paper so that the sum of all integers written on the paper equalled 2v - 1 for some integer v (v ≥ 0).
Help Ivan, find the required quantity of numbers.
Input
The first line contains integer n (1 ≤ n ≤ 105). The second input line contains n space-separated integers a1, a2, ..., an (0 ≤ ai ≤ 2·109). It is guaranteed that a1 ≤ a2 ≤ ... ≤ an.
Output
Print a single integer — the answer to the problem.
Examples
Input
4
0 1 1 1
Output
0
Input
1
3
Output
3
Note
In the first sample you do not need to add anything, the sum of numbers already equals 23 - 1 = 7.
In the second sample you need to add numbers 20, 21, 22. | instruction | 0 | 87,883 | 12 | 175,766 |
Tags: greedy, implementation
Correct Solution:
```
n=int(input())
a=list(map(int,input().split()))
b=0
c=0
d=0
for i in range(1,n):
if a[i]!=a[i-1]:
c+=1-(i-b+d)%2
d=(i-b+d)//2
j=a[i-1]+1
while j<a[i] and d>0:
c+=1-d%2
d//=2
j+=1
c+=a[i]-j
b=i
c+=1-(n-b+d)%2
d=(n-b+d)//2
j=a[-1]+1
while d>0:
c+=1-d%2
d//=2
j+=1
print(c+a[0])
``` | output | 1 | 87,883 | 12 | 175,767 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ivan has got an array of n non-negative integers a1, a2, ..., an. Ivan knows that the array is sorted in the non-decreasing order.
Ivan wrote out integers 2a1, 2a2, ..., 2an on a piece of paper. Now he wonders, what minimum number of integers of form 2b (b ≥ 0) need to be added to the piece of paper so that the sum of all integers written on the paper equalled 2v - 1 for some integer v (v ≥ 0).
Help Ivan, find the required quantity of numbers.
Input
The first line contains integer n (1 ≤ n ≤ 105). The second input line contains n space-separated integers a1, a2, ..., an (0 ≤ ai ≤ 2·109). It is guaranteed that a1 ≤ a2 ≤ ... ≤ an.
Output
Print a single integer — the answer to the problem.
Examples
Input
4
0 1 1 1
Output
0
Input
1
3
Output
3
Note
In the first sample you do not need to add anything, the sum of numbers already equals 23 - 1 = 7.
In the second sample you need to add numbers 20, 21, 22. | instruction | 0 | 87,884 | 12 | 175,768 |
Tags: greedy, implementation
Correct Solution:
```
n=int(input())
a=map(int,input().split())
st=set()
for e in a :
while(e in st):
st.remove(e)
e+=1
st.add(e)
print(max(st)-len(st)+1)
``` | output | 1 | 87,884 | 12 | 175,769 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ivan has got an array of n non-negative integers a1, a2, ..., an. Ivan knows that the array is sorted in the non-decreasing order.
Ivan wrote out integers 2a1, 2a2, ..., 2an on a piece of paper. Now he wonders, what minimum number of integers of form 2b (b ≥ 0) need to be added to the piece of paper so that the sum of all integers written on the paper equalled 2v - 1 for some integer v (v ≥ 0).
Help Ivan, find the required quantity of numbers.
Input
The first line contains integer n (1 ≤ n ≤ 105). The second input line contains n space-separated integers a1, a2, ..., an (0 ≤ ai ≤ 2·109). It is guaranteed that a1 ≤ a2 ≤ ... ≤ an.
Output
Print a single integer — the answer to the problem.
Examples
Input
4
0 1 1 1
Output
0
Input
1
3
Output
3
Note
In the first sample you do not need to add anything, the sum of numbers already equals 23 - 1 = 7.
In the second sample you need to add numbers 20, 21, 22. | instruction | 0 | 87,885 | 12 | 175,770 |
Tags: greedy, implementation
Correct Solution:
```
from heapq import heapify, heappush, heappop
n = int(input())
a = list(map(int, input().split()))
q = []; cnt = 1; d = {}
for i in range(1, n):
if a[i] == a[i-1]:
cnt += 1
else:
q.append(a[i-1])
d[a[i-1]] = cnt
cnt = 1
q.append(a[-1])
d[a[-1]] = cnt
heapify(q); maxpow = 0
while len(q) != 0:
x = heappop(q)
maxpow = max(maxpow, x)
bineq = bin(d[x])[2:][::-1]
#print(x, d[x], bineq)
for i in range(len(bineq)):
if i == 0:
if bineq[i] == '0':
del d[x+i]
else:
d[x+i] = 1
else:
if bineq[i] == '1':
if x+i in d:
d[x+i] += 1
else:
d[x+i] = 1
heappush(q, x+i)
print(maxpow + 1 - len(d))
``` | output | 1 | 87,885 | 12 | 175,771 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ivan has got an array of n non-negative integers a1, a2, ..., an. Ivan knows that the array is sorted in the non-decreasing order.
Ivan wrote out integers 2a1, 2a2, ..., 2an on a piece of paper. Now he wonders, what minimum number of integers of form 2b (b ≥ 0) need to be added to the piece of paper so that the sum of all integers written on the paper equalled 2v - 1 for some integer v (v ≥ 0).
Help Ivan, find the required quantity of numbers.
Input
The first line contains integer n (1 ≤ n ≤ 105). The second input line contains n space-separated integers a1, a2, ..., an (0 ≤ ai ≤ 2·109). It is guaranteed that a1 ≤ a2 ≤ ... ≤ an.
Output
Print a single integer — the answer to the problem.
Examples
Input
4
0 1 1 1
Output
0
Input
1
3
Output
3
Note
In the first sample you do not need to add anything, the sum of numbers already equals 23 - 1 = 7.
In the second sample you need to add numbers 20, 21, 22. | instruction | 0 | 87,886 | 12 | 175,772 |
Tags: greedy, implementation
Correct Solution:
```
# array de indices em ordem crescente
# quantos 2**b precisa para 2**v-1 (soma de sequencia)
import math
def main():
n = int(input())
a = input().split()
a = [int(x) for x in a]
p = 0
carry = 0
ok = 0
while p<n:
count = carry
atual = a[p]
while p<n and a[p] == atual:
count += 1
p += 1
if count%2 == 1:
ok += 1
carry = count//2
if p<n:
proximo = a[p]
else:
proximo = atual-1
while carry!= 0 and proximo!= atual+1:
if carry%2 == 1:
ok += 1
carry = carry//2
atual += 1
print(atual-ok+1)
main()
``` | output | 1 | 87,886 | 12 | 175,773 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ivan has got an array of n non-negative integers a1, a2, ..., an. Ivan knows that the array is sorted in the non-decreasing order.
Ivan wrote out integers 2a1, 2a2, ..., 2an on a piece of paper. Now he wonders, what minimum number of integers of form 2b (b ≥ 0) need to be added to the piece of paper so that the sum of all integers written on the paper equalled 2v - 1 for some integer v (v ≥ 0).
Help Ivan, find the required quantity of numbers.
Input
The first line contains integer n (1 ≤ n ≤ 105). The second input line contains n space-separated integers a1, a2, ..., an (0 ≤ ai ≤ 2·109). It is guaranteed that a1 ≤ a2 ≤ ... ≤ an.
Output
Print a single integer — the answer to the problem.
Examples
Input
4
0 1 1 1
Output
0
Input
1
3
Output
3
Note
In the first sample you do not need to add anything, the sum of numbers already equals 23 - 1 = 7.
In the second sample you need to add numbers 20, 21, 22. | instruction | 0 | 87,887 | 12 | 175,774 |
Tags: greedy, implementation
Correct Solution:
```
from sys import stdin, stdout
inputIdx = 0;
input = stdin.read().strip().split();
def nextToken():
global inputIdx, input;
token = input[inputIdx];
inputIdx += 1;
return token;
def main():
global inputIdx, input;
while inputIdx < len(input):
n = int( nextToken() );
arr = [ int( nextToken() ) for i in range(n) ];
diff = 0;
cur = -1; cnt = 0;
i = 0;
ans = max(arr);
while i < n or cur != -1:
ans = max( ans, cur );
if ( i < n and cur != -1 and arr[i] == cur ) or ( cur == -1 ):
j = i;
while j < n and arr[i] == arr[j]:
j += 1;
cnt += j-i;
cur = arr[i];
i = j;
if (cnt&1) == 1:
diff += 1;
cur += 1;
cnt //= 2;
if cnt == 0:
cur = -1;
ans -= diff-1;
print( int(ans) );
main();
``` | output | 1 | 87,887 | 12 | 175,775 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ivan has got an array of n non-negative integers a1, a2, ..., an. Ivan knows that the array is sorted in the non-decreasing order.
Ivan wrote out integers 2a1, 2a2, ..., 2an on a piece of paper. Now he wonders, what minimum number of integers of form 2b (b ≥ 0) need to be added to the piece of paper so that the sum of all integers written on the paper equalled 2v - 1 for some integer v (v ≥ 0).
Help Ivan, find the required quantity of numbers.
Input
The first line contains integer n (1 ≤ n ≤ 105). The second input line contains n space-separated integers a1, a2, ..., an (0 ≤ ai ≤ 2·109). It is guaranteed that a1 ≤ a2 ≤ ... ≤ an.
Output
Print a single integer — the answer to the problem.
Examples
Input
4
0 1 1 1
Output
0
Input
1
3
Output
3
Note
In the first sample you do not need to add anything, the sum of numbers already equals 23 - 1 = 7.
In the second sample you need to add numbers 20, 21, 22. | instruction | 0 | 87,888 | 12 | 175,776 |
Tags: greedy, implementation
Correct Solution:
```
n = int(input())
seq = [int(x) for x in input().split()]
def inseri(s, n):
if n in s:
s.remove(n)
inseri(s, n+1)
else:
s.add(n)
s = set()
for i in seq:
inseri(s, i)
m = max(s)
print(m-len(s)+1)
``` | output | 1 | 87,888 | 12 | 175,777 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ivan has got an array of n non-negative integers a1, a2, ..., an. Ivan knows that the array is sorted in the non-decreasing order.
Ivan wrote out integers 2a1, 2a2, ..., 2an on a piece of paper. Now he wonders, what minimum number of integers of form 2b (b ≥ 0) need to be added to the piece of paper so that the sum of all integers written on the paper equalled 2v - 1 for some integer v (v ≥ 0).
Help Ivan, find the required quantity of numbers.
Input
The first line contains integer n (1 ≤ n ≤ 105). The second input line contains n space-separated integers a1, a2, ..., an (0 ≤ ai ≤ 2·109). It is guaranteed that a1 ≤ a2 ≤ ... ≤ an.
Output
Print a single integer — the answer to the problem.
Examples
Input
4
0 1 1 1
Output
0
Input
1
3
Output
3
Note
In the first sample you do not need to add anything, the sum of numbers already equals 23 - 1 = 7.
In the second sample you need to add numbers 20, 21, 22. | instruction | 0 | 87,889 | 12 | 175,778 |
Tags: greedy, implementation
Correct Solution:
```
input()
now = alc = ans = 0
for v in map(int, input().split()):
while alc and now != v:
ans += not (alc & 1)
alc >>= 1
now += 1
ans += v - now
alc += 1
now = v
else:
while alc:
ans += not (alc & 1)
alc >>= 1
print(ans)
``` | output | 1 | 87,889 | 12 | 175,779 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ivan has got an array of n non-negative integers a1, a2, ..., an. Ivan knows that the array is sorted in the non-decreasing order.
Ivan wrote out integers 2a1, 2a2, ..., 2an on a piece of paper. Now he wonders, what minimum number of integers of form 2b (b ≥ 0) need to be added to the piece of paper so that the sum of all integers written on the paper equalled 2v - 1 for some integer v (v ≥ 0).
Help Ivan, find the required quantity of numbers.
Input
The first line contains integer n (1 ≤ n ≤ 105). The second input line contains n space-separated integers a1, a2, ..., an (0 ≤ ai ≤ 2·109). It is guaranteed that a1 ≤ a2 ≤ ... ≤ an.
Output
Print a single integer — the answer to the problem.
Examples
Input
4
0 1 1 1
Output
0
Input
1
3
Output
3
Note
In the first sample you do not need to add anything, the sum of numbers already equals 23 - 1 = 7.
In the second sample you need to add numbers 20, 21, 22. | instruction | 0 | 87,890 | 12 | 175,780 |
Tags: greedy, implementation
Correct Solution:
```
from sys import stdin
N = int(stdin.readline())
num = set()
for b in map(int, stdin.readline().split()):
while b in num:
num.remove(b)
b += 1
num.add(b)
print(max(num) - len(num) + 1)
``` | output | 1 | 87,890 | 12 | 175,781 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is an interactive problem. You have to use flush operation right after printing each line. For example, in C++ you should use function fflush(stdout), in Java — System.out.flush(), in Pascal — flush(output) and in Python — sys.stdout.flush().
In this problem, you need to find maximal and minimal elements of an array. What could be simpler?
You can imagine that the jury has an array, and initially you know the only number n — array's length.
Array's elements are numbered from 1 to n. You are allowed to compare two elements of the array by using their indices i and j. There are three possible responses to this query: '<' (if ai is less than aj), '=' (if ai is equal to aj) and finally '>' (if ai is greater than aj).
It's known that it's always possible to find both maximal and minimal elements of the array by using no more than <image> comparisons, where ⌈ x⌉ is the result of rounding x up.
Write the program that will find positions of the minimum and the maximum in the jury's array of length n, by using no more than f(n) comparisons.
Interaction
Each test for this problem will contain one or more arrays. You have to find positions of minimal and maximal elements for each of these arrays. The first line of the input contains integer T (1 ≤ T ≤ 1000) — number of arrays in the test.
Thus, at the beginning, you program should read number T, and then it should solve the problem for T jury's arrays one by one.
Then input for each array goes. Firstly, your program has to read the number n (1 ≤ n ≤ 50) — the length of the array. It will be provided in the next line of the input.
Further, your program can perform comparisons or report that the answer is found.
* To perform a comparison, you have to output string of the following pattern «? i j» (i and j must be integer numbers from 1 to n) — the indices of the elements to compare in the current query.
* To report the indices of minimal and maximal elements of the hidden array, your program have to output a line in the form «! i j» (i and j must be integer numbers from 1 to n), where i is an index of the minimal element of array, and j is an index of the maximal element of the array. If there are several possible answers to the problem, you can output any of them.
There are several possible responses for a comparison:
* '<' — if ai is less than aj,
* '=' — if ai is equal to aj,
* '>' — if ai is greater than aj.
For an array of length n your program can make at most <image> comparisons. Note that the operation of reporting an answer («! i j» ) is not included into the value of f(n).
After the answer is reported, your program has to solve the problem for the next array or it should terminate if all T arrays are processed.
Example
Input
2
2
>
3
=
=
Output
? 1 2
! 2 1
? 3 1
? 2 1
! 2 3 | instruction | 0 | 88,016 | 12 | 176,032 |
Tags: constructive algorithms, interactive
Correct Solution:
```
from collections import defaultdict
for ik in range(int(input())):
n=int(input())
d=defaultdict(str)
if n==1:
print("! 1 1",flush=True)
continue
elif n==2:
print("? 1 2",flush=True)
s=input()
if s==">":
print("! 2 1",flush=True)
else:
print("! 1 2",flush=True)
continue
last=[i for i in range(1,n+1)]
res=[]
while(len(last)!=1):
for i in range(len(last)//2):
print("?", last[2*i], last[2*i+1], flush=True)
r=input()
d[(last[2 * i], last[2 * i + 1])] = r
if r=='>':
res.append(last[2*i])
else:
res.append(last[2*i+1])
if len(last)%2==1:
res.append(last[-1])
last=res+[]
res=[]
max=last[0]
#print(max)
last = [i for i in range(1, n+1)]
res = []
while (len(last) != 1):
for i in range(len(last)// 2):
if (last[2*i],last[2*i+1]) in d:
r1=d[(last[2*i],last[2*i+1])]
else:
print("?", last[2 * i], last[2 * i + 1], flush=True)
r1 = input()
if r1 == '<':
res.append(last[2 * i])
else:
res.append(last[2 * i + 1])
if len(last) % 2 == 1:
res.append(last[-1])
last = res + []
res = []
min = last[0]
print('!',min,max,flush=True)
``` | output | 1 | 88,016 | 12 | 176,033 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is an interactive problem. You have to use flush operation right after printing each line. For example, in C++ you should use function fflush(stdout), in Java — System.out.flush(), in Pascal — flush(output) and in Python — sys.stdout.flush().
In this problem, you need to find maximal and minimal elements of an array. What could be simpler?
You can imagine that the jury has an array, and initially you know the only number n — array's length.
Array's elements are numbered from 1 to n. You are allowed to compare two elements of the array by using their indices i and j. There are three possible responses to this query: '<' (if ai is less than aj), '=' (if ai is equal to aj) and finally '>' (if ai is greater than aj).
It's known that it's always possible to find both maximal and minimal elements of the array by using no more than <image> comparisons, where ⌈ x⌉ is the result of rounding x up.
Write the program that will find positions of the minimum and the maximum in the jury's array of length n, by using no more than f(n) comparisons.
Interaction
Each test for this problem will contain one or more arrays. You have to find positions of minimal and maximal elements for each of these arrays. The first line of the input contains integer T (1 ≤ T ≤ 1000) — number of arrays in the test.
Thus, at the beginning, you program should read number T, and then it should solve the problem for T jury's arrays one by one.
Then input for each array goes. Firstly, your program has to read the number n (1 ≤ n ≤ 50) — the length of the array. It will be provided in the next line of the input.
Further, your program can perform comparisons or report that the answer is found.
* To perform a comparison, you have to output string of the following pattern «? i j» (i and j must be integer numbers from 1 to n) — the indices of the elements to compare in the current query.
* To report the indices of minimal and maximal elements of the hidden array, your program have to output a line in the form «! i j» (i and j must be integer numbers from 1 to n), where i is an index of the minimal element of array, and j is an index of the maximal element of the array. If there are several possible answers to the problem, you can output any of them.
There are several possible responses for a comparison:
* '<' — if ai is less than aj,
* '=' — if ai is equal to aj,
* '>' — if ai is greater than aj.
For an array of length n your program can make at most <image> comparisons. Note that the operation of reporting an answer («! i j» ) is not included into the value of f(n).
After the answer is reported, your program has to solve the problem for the next array or it should terminate if all T arrays are processed.
Example
Input
2
2
>
3
=
=
Output
? 1 2
! 2 1
? 3 1
? 2 1
! 2 3 | instruction | 0 | 88,017 | 12 | 176,034 |
Tags: constructive algorithms, interactive
Correct Solution:
```
import sys
T = int(input())
def compare(l,r,arr):
print('?',a[l]+1,a[r]+1)
sys.stdout.flush()
res = input()
if (res == '>'): return 1;
else: return 0;
while (T > 0):
T -= 1
Max_a = []
Min_a = []
n = int(input())
a = range(n)
for i in range(int(n/2)):
if (compare(i*2,i*2+1,a) > 0):
Max_a.append(i*2)
Min_a.append(i*2+1)
else :
Max_a.append(i*2+1)
Min_a.append(i*2)
if (n%2 == 1):
Max_a.append(n-1)
Min_a.append(n-1)
Max_index = Max_a[-1]
Min_index = Min_a[-1]
for i in range(len(Max_a)-1):
if (compare(Max_a[i],Max_index,a) > 0):
Max_index = Max_a[i]
for i in range(len(Min_a)-1):
if (compare(Min_a[i],Min_index,a) == 0):
Min_index = Min_a[i]
print('!',Min_index+1,Max_index+1)
sys.stdout.flush()
``` | output | 1 | 88,017 | 12 | 176,035 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is an interactive problem. You have to use flush operation right after printing each line. For example, in C++ you should use function fflush(stdout), in Java — System.out.flush(), in Pascal — flush(output) and in Python — sys.stdout.flush().
In this problem, you need to find maximal and minimal elements of an array. What could be simpler?
You can imagine that the jury has an array, and initially you know the only number n — array's length.
Array's elements are numbered from 1 to n. You are allowed to compare two elements of the array by using their indices i and j. There are three possible responses to this query: '<' (if ai is less than aj), '=' (if ai is equal to aj) and finally '>' (if ai is greater than aj).
It's known that it's always possible to find both maximal and minimal elements of the array by using no more than <image> comparisons, where ⌈ x⌉ is the result of rounding x up.
Write the program that will find positions of the minimum and the maximum in the jury's array of length n, by using no more than f(n) comparisons.
Interaction
Each test for this problem will contain one or more arrays. You have to find positions of minimal and maximal elements for each of these arrays. The first line of the input contains integer T (1 ≤ T ≤ 1000) — number of arrays in the test.
Thus, at the beginning, you program should read number T, and then it should solve the problem for T jury's arrays one by one.
Then input for each array goes. Firstly, your program has to read the number n (1 ≤ n ≤ 50) — the length of the array. It will be provided in the next line of the input.
Further, your program can perform comparisons or report that the answer is found.
* To perform a comparison, you have to output string of the following pattern «? i j» (i and j must be integer numbers from 1 to n) — the indices of the elements to compare in the current query.
* To report the indices of minimal and maximal elements of the hidden array, your program have to output a line in the form «! i j» (i and j must be integer numbers from 1 to n), where i is an index of the minimal element of array, and j is an index of the maximal element of the array. If there are several possible answers to the problem, you can output any of them.
There are several possible responses for a comparison:
* '<' — if ai is less than aj,
* '=' — if ai is equal to aj,
* '>' — if ai is greater than aj.
For an array of length n your program can make at most <image> comparisons. Note that the operation of reporting an answer («! i j» ) is not included into the value of f(n).
After the answer is reported, your program has to solve the problem for the next array or it should terminate if all T arrays are processed.
Example
Input
2
2
>
3
=
=
Output
? 1 2
! 2 1
? 3 1
? 2 1
! 2 3 | instruction | 0 | 88,018 | 12 | 176,036 |
Tags: constructive algorithms, interactive
Correct Solution:
```
import sys
def f(arr):
mn, mx = [], []
for i in range(len(arr) // 2):
print('?', arr[2*i], arr[2*i + 1])
sys.stdout.flush()
if input() == '>':
mn.append(arr[2*i + 1])
mx.append(arr[2*i])
else:
mn.append(arr[2*i])
mx.append(arr[2*i + 1])
if len(arr) % 2 == 1:
mn.append(arr[-1])
mx.append(arr[-1])
return (mn, mx)
for _ in range(int(input())):
n = int(input())
arr = range(1, n+1)
mn, mx = f(arr)
while len(mn) > 1:
mn = f(mn)[0]
while len(mx) > 1:
mx = f(mx)[1]
print('!',mn[0],mx[0])
sys.stdout.flush()
# Made By Mostafa_Khaled
``` | output | 1 | 88,018 | 12 | 176,037 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is an interactive problem. You have to use flush operation right after printing each line. For example, in C++ you should use function fflush(stdout), in Java — System.out.flush(), in Pascal — flush(output) and in Python — sys.stdout.flush().
In this problem, you need to find maximal and minimal elements of an array. What could be simpler?
You can imagine that the jury has an array, and initially you know the only number n — array's length.
Array's elements are numbered from 1 to n. You are allowed to compare two elements of the array by using their indices i and j. There are three possible responses to this query: '<' (if ai is less than aj), '=' (if ai is equal to aj) and finally '>' (if ai is greater than aj).
It's known that it's always possible to find both maximal and minimal elements of the array by using no more than <image> comparisons, where ⌈ x⌉ is the result of rounding x up.
Write the program that will find positions of the minimum and the maximum in the jury's array of length n, by using no more than f(n) comparisons.
Interaction
Each test for this problem will contain one or more arrays. You have to find positions of minimal and maximal elements for each of these arrays. The first line of the input contains integer T (1 ≤ T ≤ 1000) — number of arrays in the test.
Thus, at the beginning, you program should read number T, and then it should solve the problem for T jury's arrays one by one.
Then input for each array goes. Firstly, your program has to read the number n (1 ≤ n ≤ 50) — the length of the array. It will be provided in the next line of the input.
Further, your program can perform comparisons or report that the answer is found.
* To perform a comparison, you have to output string of the following pattern «? i j» (i and j must be integer numbers from 1 to n) — the indices of the elements to compare in the current query.
* To report the indices of minimal and maximal elements of the hidden array, your program have to output a line in the form «! i j» (i and j must be integer numbers from 1 to n), where i is an index of the minimal element of array, and j is an index of the maximal element of the array. If there are several possible answers to the problem, you can output any of them.
There are several possible responses for a comparison:
* '<' — if ai is less than aj,
* '=' — if ai is equal to aj,
* '>' — if ai is greater than aj.
For an array of length n your program can make at most <image> comparisons. Note that the operation of reporting an answer («! i j» ) is not included into the value of f(n).
After the answer is reported, your program has to solve the problem for the next array or it should terminate if all T arrays are processed.
Example
Input
2
2
>
3
=
=
Output
? 1 2
! 2 1
? 3 1
? 2 1
! 2 3 | instruction | 0 | 88,019 | 12 | 176,038 |
Tags: constructive algorithms, interactive
Correct Solution:
```
from sys import stdin, stdout
from math import sin, tan, cos
def ask(i, j):
stdout.write('? ' + str(i) + ' ' + str(j) + '\n')
stdout.flush()
return stdin.readline().strip()
T = int(stdin.readline())
for t in range(T):
n = int(stdin.readline())
if n == 1:
stdout.write('! 1 1\n')
stdout.flush()
continue
l, r = 1, 2
if ask(l, r) == '>':
l, r = r, l
for i in range(3, n + 1, 2):
if i == n:
s = ask(l, i)
f = ask(r, i)
if s == '>':
l = i
if f == '<':
r = i
continue
lb, rb = i, i + 1
if ask(lb, rb) == '>':
lb, rb = rb, lb
if ask(lb, l) == '<':
l = lb
if ask(rb, r) == '>':
r = rb
stdout.write('! ' + str(l) + ' ' + str(r) + '\n')
stdout.flush()
``` | output | 1 | 88,019 | 12 | 176,039 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is an interactive problem. You have to use flush operation right after printing each line. For example, in C++ you should use function fflush(stdout), in Java — System.out.flush(), in Pascal — flush(output) and in Python — sys.stdout.flush().
In this problem, you need to find maximal and minimal elements of an array. What could be simpler?
You can imagine that the jury has an array, and initially you know the only number n — array's length.
Array's elements are numbered from 1 to n. You are allowed to compare two elements of the array by using their indices i and j. There are three possible responses to this query: '<' (if ai is less than aj), '=' (if ai is equal to aj) and finally '>' (if ai is greater than aj).
It's known that it's always possible to find both maximal and minimal elements of the array by using no more than <image> comparisons, where ⌈ x⌉ is the result of rounding x up.
Write the program that will find positions of the minimum and the maximum in the jury's array of length n, by using no more than f(n) comparisons.
Interaction
Each test for this problem will contain one or more arrays. You have to find positions of minimal and maximal elements for each of these arrays. The first line of the input contains integer T (1 ≤ T ≤ 1000) — number of arrays in the test.
Thus, at the beginning, you program should read number T, and then it should solve the problem for T jury's arrays one by one.
Then input for each array goes. Firstly, your program has to read the number n (1 ≤ n ≤ 50) — the length of the array. It will be provided in the next line of the input.
Further, your program can perform comparisons or report that the answer is found.
* To perform a comparison, you have to output string of the following pattern «? i j» (i and j must be integer numbers from 1 to n) — the indices of the elements to compare in the current query.
* To report the indices of minimal and maximal elements of the hidden array, your program have to output a line in the form «! i j» (i and j must be integer numbers from 1 to n), where i is an index of the minimal element of array, and j is an index of the maximal element of the array. If there are several possible answers to the problem, you can output any of them.
There are several possible responses for a comparison:
* '<' — if ai is less than aj,
* '=' — if ai is equal to aj,
* '>' — if ai is greater than aj.
For an array of length n your program can make at most <image> comparisons. Note that the operation of reporting an answer («! i j» ) is not included into the value of f(n).
After the answer is reported, your program has to solve the problem for the next array or it should terminate if all T arrays are processed.
Example
Input
2
2
>
3
=
=
Output
? 1 2
! 2 1
? 3 1
? 2 1
! 2 3 | instruction | 0 | 88,020 | 12 | 176,040 |
Tags: constructive algorithms, interactive
Correct Solution:
```
# Online Python compiler (interpreter) to run Python online.
# Write Python 3 code in this online editor and run it.
# Online Python compiler (interpreter) to run Python online.
# Write Python 3 code in this online editor and run it.
import sys
def obtain_min_max(left, right):
print("?", left, right)
sys.stdout.flush()
k = input()
if k == "=":
return (left, left)
elif k == "<":
return (left, right)
else:
return (right, left)
def solve_aux(left, right):
if left == right:
return (left, left)
if right == left + 1:
return obtain_min_max(left, right)
mid = (left + right)//2
if (mid - left + 1) % 2 == 1 and (right - mid) % 2 == 1:
mid -= 1
(min1, max1) = solve_aux(left, mid)
(min2, max2) = solve_aux(mid + 1, right)
(min_min, min_max) = obtain_min_max(min1, min2)
(max_min, max_max) = obtain_min_max(max1, max2)
return (min_min, max_max)
def solve(k):
return solve_aux(1, k)
n = int(input())
for i in range(n):
k = int(input())
(min, max) = solve(k)
print("!", min, max)
sys.stdout.flush()
``` | output | 1 | 88,020 | 12 | 176,041 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is an interactive problem. You have to use flush operation right after printing each line. For example, in C++ you should use function fflush(stdout), in Java — System.out.flush(), in Pascal — flush(output) and in Python — sys.stdout.flush().
In this problem, you need to find maximal and minimal elements of an array. What could be simpler?
You can imagine that the jury has an array, and initially you know the only number n — array's length.
Array's elements are numbered from 1 to n. You are allowed to compare two elements of the array by using their indices i and j. There are three possible responses to this query: '<' (if ai is less than aj), '=' (if ai is equal to aj) and finally '>' (if ai is greater than aj).
It's known that it's always possible to find both maximal and minimal elements of the array by using no more than <image> comparisons, where ⌈ x⌉ is the result of rounding x up.
Write the program that will find positions of the minimum and the maximum in the jury's array of length n, by using no more than f(n) comparisons.
Interaction
Each test for this problem will contain one or more arrays. You have to find positions of minimal and maximal elements for each of these arrays. The first line of the input contains integer T (1 ≤ T ≤ 1000) — number of arrays in the test.
Thus, at the beginning, you program should read number T, and then it should solve the problem for T jury's arrays one by one.
Then input for each array goes. Firstly, your program has to read the number n (1 ≤ n ≤ 50) — the length of the array. It will be provided in the next line of the input.
Further, your program can perform comparisons or report that the answer is found.
* To perform a comparison, you have to output string of the following pattern «? i j» (i and j must be integer numbers from 1 to n) — the indices of the elements to compare in the current query.
* To report the indices of minimal and maximal elements of the hidden array, your program have to output a line in the form «! i j» (i and j must be integer numbers from 1 to n), where i is an index of the minimal element of array, and j is an index of the maximal element of the array. If there are several possible answers to the problem, you can output any of them.
There are several possible responses for a comparison:
* '<' — if ai is less than aj,
* '=' — if ai is equal to aj,
* '>' — if ai is greater than aj.
For an array of length n your program can make at most <image> comparisons. Note that the operation of reporting an answer («! i j» ) is not included into the value of f(n).
After the answer is reported, your program has to solve the problem for the next array or it should terminate if all T arrays are processed.
Example
Input
2
2
>
3
=
=
Output
? 1 2
! 2 1
? 3 1
? 2 1
! 2 3 | instruction | 0 | 88,021 | 12 | 176,042 |
Tags: constructive algorithms, interactive
Correct Solution:
```
"""
Author - Satwik Tiwari .
"""
#===============================================================================================
#importing some useful libraries.
from __future__ import division, print_function
from fractions import Fraction
import sys
import os
from io import BytesIO, IOBase
from functools import cmp_to_key
# from itertools import *
from heapq import *
from math import gcd, factorial,floor,ceil,sqrt,log2
from copy import deepcopy
from collections import deque
from bisect import bisect_left as bl
from bisect import bisect_right as br
from bisect import bisect
#==============================================================================================
#fast I/O region
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")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
if sys.version_info[0] < 3:
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
# inp = lambda: sys.stdin.readline().rstrip("\r\n")
#===============================================================================================
### START ITERATE RECURSION ###
from types import GeneratorType
def iterative(f, stack=[]):
def wrapped_func(*args, **kwargs):
if stack: return f(*args, **kwargs)
to = f(*args, **kwargs)
while True:
if type(to) is GeneratorType:
stack.append(to)
to = next(to)
continue
stack.pop()
if not stack: break
to = stack[-1].send(to)
return to
return wrapped_func
#### END ITERATE RECURSION ####
#===============================================================================================
#some shortcuts
def inp(): return sys.stdin.readline().rstrip("\r\n") #for fast input
def out(var): sys.stdout.write(str(var)) #for fast output, always take string
def lis(): return list(map(int, inp().split()))
def stringlis(): return list(map(str, inp().split()))
def sep(): return map(int, inp().split())
def strsep(): return map(str, inp().split())
# def graph(vertex): return [[] for i in range(0,vertex+1)]
def testcase(t):
for pp in range(t):
solve(pp)
def google(p):
print('Case #'+str(p)+': ',end='')
def lcm(a,b): return (a*b)//gcd(a,b)
def modInverse(b):
g = gcd(b, mod)
if (g != 1):
# print("Inverse doesn't exist")
return -1
else:
# If b and m are relatively prime,
# then modulo inverse is b^(m-2) mode m
return pow(b, mod - 2, mod)
def power(x, y, p) :
y%=(p-1) #not so sure about this. used when y>p-1. if p is prime.
res = 1 # Initialize result
x = x % p # Update x if it is more , than or equal to p
if (x == 0) :
return 0
while (y > 0) :
if ((y & 1) == 1) : # If y is odd, multiply, x with result
res = (res * x) % p
y = y >> 1 # y = y/2
x = (x * x) % p
return res
def isPrime(n) :
if (n <= 1) : return False
if (n <= 3) : return True
if (n % 2 == 0 or n % 3 == 0) : return False
i = 5
while(i * i <= n) :
if (n % i == 0 or n % (i + 2) == 0) :
return False
i = i + 6
return True
inf = pow(10,20)
mod = 10**9+7
#===============================================================================================
# code here ;))
def ask(a,b):
print('?',a+1,b+1)
sys.stdout.flush()
s = inp()
return s
def solve(case):
n = int(inp())
if(n == 1):
print('!',1,1)
sys.stdout.flush()
return
max = []
min = []
for i in range(0,n,2):
if(i == n-1):
max.append(i)
min.append(i)
else:
temp = ask(i,i+1)
if(temp == '<' or temp == '='):
min.append(i)
max.append(i+1)
if(temp == '>'):
min.append(i+1)
max.append(i)
while(len(max) > 1):
new = []
for i in range(0,len(max),2):
if(i == len(max) - 1):
new.append(max[i])
else:
temp = ask(max[i],max[i+1])
if(temp == '<' or temp == '='):
new.append(max[i+1])
else:
new.append(max[i])
max = deepcopy(new)
maxans = max[0]
while (len(min) > 1):
new = []
for i in range(0, len(min), 2):
if (i == len(min) - 1):
new.append(min[i])
else:
temp = ask(min[i], min[i + 1])
if (temp == '<' or temp == '='):
new.append(min[i])
else:
new.append(min[i + 1])
min = deepcopy(new)
minans = min[0]
print('!',minans + 1,maxans + 1)
sys.stdout.flush()
# testcase(1)
testcase(int(inp()))
``` | output | 1 | 88,021 | 12 | 176,043 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is an interactive problem. You have to use flush operation right after printing each line. For example, in C++ you should use function fflush(stdout), in Java — System.out.flush(), in Pascal — flush(output) and in Python — sys.stdout.flush().
In this problem, you need to find maximal and minimal elements of an array. What could be simpler?
You can imagine that the jury has an array, and initially you know the only number n — array's length.
Array's elements are numbered from 1 to n. You are allowed to compare two elements of the array by using their indices i and j. There are three possible responses to this query: '<' (if ai is less than aj), '=' (if ai is equal to aj) and finally '>' (if ai is greater than aj).
It's known that it's always possible to find both maximal and minimal elements of the array by using no more than <image> comparisons, where ⌈ x⌉ is the result of rounding x up.
Write the program that will find positions of the minimum and the maximum in the jury's array of length n, by using no more than f(n) comparisons.
Interaction
Each test for this problem will contain one or more arrays. You have to find positions of minimal and maximal elements for each of these arrays. The first line of the input contains integer T (1 ≤ T ≤ 1000) — number of arrays in the test.
Thus, at the beginning, you program should read number T, and then it should solve the problem for T jury's arrays one by one.
Then input for each array goes. Firstly, your program has to read the number n (1 ≤ n ≤ 50) — the length of the array. It will be provided in the next line of the input.
Further, your program can perform comparisons or report that the answer is found.
* To perform a comparison, you have to output string of the following pattern «? i j» (i and j must be integer numbers from 1 to n) — the indices of the elements to compare in the current query.
* To report the indices of minimal and maximal elements of the hidden array, your program have to output a line in the form «! i j» (i and j must be integer numbers from 1 to n), where i is an index of the minimal element of array, and j is an index of the maximal element of the array. If there are several possible answers to the problem, you can output any of them.
There are several possible responses for a comparison:
* '<' — if ai is less than aj,
* '=' — if ai is equal to aj,
* '>' — if ai is greater than aj.
For an array of length n your program can make at most <image> comparisons. Note that the operation of reporting an answer («! i j» ) is not included into the value of f(n).
After the answer is reported, your program has to solve the problem for the next array or it should terminate if all T arrays are processed.
Example
Input
2
2
>
3
=
=
Output
? 1 2
! 2 1
? 3 1
? 2 1
! 2 3 | instruction | 0 | 88,022 | 12 | 176,044 |
Tags: constructive algorithms, interactive
Correct Solution:
```
import sys
def f(arr):
mn, mx = [], []
for i in range(len(arr) // 2):
print('?', arr[2*i], arr[2*i + 1])
sys.stdout.flush()
if input() == '>':
mn.append(arr[2*i + 1])
mx.append(arr[2*i])
else:
mn.append(arr[2*i])
mx.append(arr[2*i + 1])
if len(arr) % 2 == 1:
mn.append(arr[-1])
mx.append(arr[-1])
return (mn, mx)
for _ in range(int(input())):
n = int(input())
arr = range(1, n+1)
mn, mx = f(arr)
while len(mn) > 1:
mn = f(mn)[0]
while len(mx) > 1:
mx = f(mx)[1]
print('!',mn[0],mx[0])
sys.stdout.flush()
``` | output | 1 | 88,022 | 12 | 176,045 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is an interactive problem. You have to use flush operation right after printing each line. For example, in C++ you should use function fflush(stdout), in Java — System.out.flush(), in Pascal — flush(output) and in Python — sys.stdout.flush().
In this problem, you need to find maximal and minimal elements of an array. What could be simpler?
You can imagine that the jury has an array, and initially you know the only number n — array's length.
Array's elements are numbered from 1 to n. You are allowed to compare two elements of the array by using their indices i and j. There are three possible responses to this query: '<' (if ai is less than aj), '=' (if ai is equal to aj) and finally '>' (if ai is greater than aj).
It's known that it's always possible to find both maximal and minimal elements of the array by using no more than <image> comparisons, where ⌈ x⌉ is the result of rounding x up.
Write the program that will find positions of the minimum and the maximum in the jury's array of length n, by using no more than f(n) comparisons.
Interaction
Each test for this problem will contain one or more arrays. You have to find positions of minimal and maximal elements for each of these arrays. The first line of the input contains integer T (1 ≤ T ≤ 1000) — number of arrays in the test.
Thus, at the beginning, you program should read number T, and then it should solve the problem for T jury's arrays one by one.
Then input for each array goes. Firstly, your program has to read the number n (1 ≤ n ≤ 50) — the length of the array. It will be provided in the next line of the input.
Further, your program can perform comparisons or report that the answer is found.
* To perform a comparison, you have to output string of the following pattern «? i j» (i and j must be integer numbers from 1 to n) — the indices of the elements to compare in the current query.
* To report the indices of minimal and maximal elements of the hidden array, your program have to output a line in the form «! i j» (i and j must be integer numbers from 1 to n), where i is an index of the minimal element of array, and j is an index of the maximal element of the array. If there are several possible answers to the problem, you can output any of them.
There are several possible responses for a comparison:
* '<' — if ai is less than aj,
* '=' — if ai is equal to aj,
* '>' — if ai is greater than aj.
For an array of length n your program can make at most <image> comparisons. Note that the operation of reporting an answer («! i j» ) is not included into the value of f(n).
After the answer is reported, your program has to solve the problem for the next array or it should terminate if all T arrays are processed.
Example
Input
2
2
>
3
=
=
Output
? 1 2
! 2 1
? 3 1
? 2 1
! 2 3 | instruction | 0 | 88,023 | 12 | 176,046 |
Tags: constructive algorithms, interactive
Correct Solution:
```
from sys import stdin, stdout
#input = stdin.buffer.readline
#print = stdout.write
def ask(i, j):
print('?', i + 1, j + 1, flush=True)
s = input()
if s == '<':
return -1
if s == '=':
return 0
return 1
def ans(i, j):
print('!', i + 1, j + 1, flush=True)
def f(i, j, c):
if (ask(i, j) > 0) ^ c:
return j
return i
def g(i, j):
if ask(i, j) < 0:
return [i, j]
return [j, i]
for _ in range(int(input())):
n = int(input())
if n == 1:
ans(0, 0)
continue
a = []
for i in range(n // 2):
a.append(g(2 * i, 2 * i + 1))
x, y = a[0][0], a[0][1]
for i in range(1, n // 2):
x = f(x, a[i][0], 0)
y = f(y, a[i][1], 1)
if n & 1:
x = f(x, n - 1, 0)
y = f(y, n - 1, 1)
ans(x, y)
``` | output | 1 | 88,023 | 12 | 176,047 |
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 have to use flush operation right after printing each line. For example, in C++ you should use function fflush(stdout), in Java — System.out.flush(), in Pascal — flush(output) and in Python — sys.stdout.flush().
In this problem, you need to find maximal and minimal elements of an array. What could be simpler?
You can imagine that the jury has an array, and initially you know the only number n — array's length.
Array's elements are numbered from 1 to n. You are allowed to compare two elements of the array by using their indices i and j. There are three possible responses to this query: '<' (if ai is less than aj), '=' (if ai is equal to aj) and finally '>' (if ai is greater than aj).
It's known that it's always possible to find both maximal and minimal elements of the array by using no more than <image> comparisons, where ⌈ x⌉ is the result of rounding x up.
Write the program that will find positions of the minimum and the maximum in the jury's array of length n, by using no more than f(n) comparisons.
Interaction
Each test for this problem will contain one or more arrays. You have to find positions of minimal and maximal elements for each of these arrays. The first line of the input contains integer T (1 ≤ T ≤ 1000) — number of arrays in the test.
Thus, at the beginning, you program should read number T, and then it should solve the problem for T jury's arrays one by one.
Then input for each array goes. Firstly, your program has to read the number n (1 ≤ n ≤ 50) — the length of the array. It will be provided in the next line of the input.
Further, your program can perform comparisons or report that the answer is found.
* To perform a comparison, you have to output string of the following pattern «? i j» (i and j must be integer numbers from 1 to n) — the indices of the elements to compare in the current query.
* To report the indices of minimal and maximal elements of the hidden array, your program have to output a line in the form «! i j» (i and j must be integer numbers from 1 to n), where i is an index of the minimal element of array, and j is an index of the maximal element of the array. If there are several possible answers to the problem, you can output any of them.
There are several possible responses for a comparison:
* '<' — if ai is less than aj,
* '=' — if ai is equal to aj,
* '>' — if ai is greater than aj.
For an array of length n your program can make at most <image> comparisons. Note that the operation of reporting an answer («! i j» ) is not included into the value of f(n).
After the answer is reported, your program has to solve the problem for the next array or it should terminate if all T arrays are processed.
Example
Input
2
2
>
3
=
=
Output
? 1 2
! 2 1
? 3 1
? 2 1
! 2 3
Submitted Solution:
```
import random
import sys
def myprint(s):
print(s)
sys.stdout.flush()
t = int(input())
while t > 0:
t -= 1
n = int(input())
A = [i+1 for i in range(n)]
allowed = 3 * n // 2 + n % 2 - 2
#print(allowed)
random.shuffle(A)
#print(A)
def cmp(x, y):
myprint("? " + str(A[x]) + " " + str(A[y]))
return input()
mins = []
maxs = []
for i in range(0, n - 1, 2):
cmpres = cmp(i, i+1)
allowed -= 1
if(cmpres == '<'):
mins.append(i)
maxs.append(i+1)
else:
mins.append(i+1)
maxs.append(i)
if n % 2 != 0:
mins.append(n - 1)
maxs.append(n - 1)
while allowed:
mn = []
mx = []
for i in range(0, len(mins) - 1, 2):
if allowed:
cmpres = cmp(mins[i], mins[i+1])
allowed -=1
if cmpres == '<':
mn.append(mins[i])
else:
mn.append(mins[i+1])
if len(mins) % 2:
mn.append(mins[-1])
for i in range(0, len(maxs) - 1, 2):
if allowed:
cmpres = cmp(maxs[i], maxs[i + 1])
allowed -= 1
if cmpres == '>':
mx.append(maxs[i])
else:
mx.append(maxs[i + 1])
if len(maxs) % 2:
mx.append(maxs[-1])
mins = mn
maxs = mx
myprint("! "+ str(A[mins[0]]) + " " + str(A[maxs[0]]))
``` | instruction | 0 | 88,024 | 12 | 176,048 |
Yes | output | 1 | 88,024 | 12 | 176,049 |
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 have to use flush operation right after printing each line. For example, in C++ you should use function fflush(stdout), in Java — System.out.flush(), in Pascal — flush(output) and in Python — sys.stdout.flush().
In this problem, you need to find maximal and minimal elements of an array. What could be simpler?
You can imagine that the jury has an array, and initially you know the only number n — array's length.
Array's elements are numbered from 1 to n. You are allowed to compare two elements of the array by using their indices i and j. There are three possible responses to this query: '<' (if ai is less than aj), '=' (if ai is equal to aj) and finally '>' (if ai is greater than aj).
It's known that it's always possible to find both maximal and minimal elements of the array by using no more than <image> comparisons, where ⌈ x⌉ is the result of rounding x up.
Write the program that will find positions of the minimum and the maximum in the jury's array of length n, by using no more than f(n) comparisons.
Interaction
Each test for this problem will contain one or more arrays. You have to find positions of minimal and maximal elements for each of these arrays. The first line of the input contains integer T (1 ≤ T ≤ 1000) — number of arrays in the test.
Thus, at the beginning, you program should read number T, and then it should solve the problem for T jury's arrays one by one.
Then input for each array goes. Firstly, your program has to read the number n (1 ≤ n ≤ 50) — the length of the array. It will be provided in the next line of the input.
Further, your program can perform comparisons or report that the answer is found.
* To perform a comparison, you have to output string of the following pattern «? i j» (i and j must be integer numbers from 1 to n) — the indices of the elements to compare in the current query.
* To report the indices of minimal and maximal elements of the hidden array, your program have to output a line in the form «! i j» (i and j must be integer numbers from 1 to n), where i is an index of the minimal element of array, and j is an index of the maximal element of the array. If there are several possible answers to the problem, you can output any of them.
There are several possible responses for a comparison:
* '<' — if ai is less than aj,
* '=' — if ai is equal to aj,
* '>' — if ai is greater than aj.
For an array of length n your program can make at most <image> comparisons. Note that the operation of reporting an answer («! i j» ) is not included into the value of f(n).
After the answer is reported, your program has to solve the problem for the next array or it should terminate if all T arrays are processed.
Example
Input
2
2
>
3
=
=
Output
? 1 2
! 2 1
? 3 1
? 2 1
! 2 3
Submitted Solution:
```
from sys import *
def f(t):
n = len(t)
k = n >> 1
u, v = [], []
if n & 1: u, v = [t[-1]], [t[-1]]
for i in range(k):
print('?', t[i], t[k + i])
stdout.flush()
q = k * (input() == '<')
u.append(t[k - q + i])
v.append(t[q + i])
return u, v
for i in range(int(input())):
u, v = f(range(1, int(input()) + 1))
while len(u) > 1: u = f(u)[0]
while len(v) > 1: v = f(v)[1]
print('!', u[0], v[0])
stdout.flush()
``` | instruction | 0 | 88,025 | 12 | 176,050 |
Yes | output | 1 | 88,025 | 12 | 176,051 |
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 have to use flush operation right after printing each line. For example, in C++ you should use function fflush(stdout), in Java — System.out.flush(), in Pascal — flush(output) and in Python — sys.stdout.flush().
In this problem, you need to find maximal and minimal elements of an array. What could be simpler?
You can imagine that the jury has an array, and initially you know the only number n — array's length.
Array's elements are numbered from 1 to n. You are allowed to compare two elements of the array by using their indices i and j. There are three possible responses to this query: '<' (if ai is less than aj), '=' (if ai is equal to aj) and finally '>' (if ai is greater than aj).
It's known that it's always possible to find both maximal and minimal elements of the array by using no more than <image> comparisons, where ⌈ x⌉ is the result of rounding x up.
Write the program that will find positions of the minimum and the maximum in the jury's array of length n, by using no more than f(n) comparisons.
Interaction
Each test for this problem will contain one or more arrays. You have to find positions of minimal and maximal elements for each of these arrays. The first line of the input contains integer T (1 ≤ T ≤ 1000) — number of arrays in the test.
Thus, at the beginning, you program should read number T, and then it should solve the problem for T jury's arrays one by one.
Then input for each array goes. Firstly, your program has to read the number n (1 ≤ n ≤ 50) — the length of the array. It will be provided in the next line of the input.
Further, your program can perform comparisons or report that the answer is found.
* To perform a comparison, you have to output string of the following pattern «? i j» (i and j must be integer numbers from 1 to n) — the indices of the elements to compare in the current query.
* To report the indices of minimal and maximal elements of the hidden array, your program have to output a line in the form «! i j» (i and j must be integer numbers from 1 to n), where i is an index of the minimal element of array, and j is an index of the maximal element of the array. If there are several possible answers to the problem, you can output any of them.
There are several possible responses for a comparison:
* '<' — if ai is less than aj,
* '=' — if ai is equal to aj,
* '>' — if ai is greater than aj.
For an array of length n your program can make at most <image> comparisons. Note that the operation of reporting an answer («! i j» ) is not included into the value of f(n).
After the answer is reported, your program has to solve the problem for the next array or it should terminate if all T arrays are processed.
Example
Input
2
2
>
3
=
=
Output
? 1 2
! 2 1
? 3 1
? 2 1
! 2 3
Submitted Solution:
```
import sys
def find_min_max(l, d=None):
#print(l)
n = len(l)
if n == 1:
return (l[0], l[0])
lesser = []
greater = []
for i in range(n//2):
first = l[2*i]
second = l[2*i + 1]
print("? {} {}".format(first, second))
sys.stdout.flush()
answer = input()
if answer == '<':
lesser.append(first)
greater.append(second)
else:
lesser.append(second)
greater.append(first)
if n%2 == 1:
lesser.append(l[-1])
greater.append(l[-1])
mn = None
mx = None
if d != 'max':
mn = find_min_max(lesser, 'min')[0]
if d != 'min':
mx = find_min_max(greater, 'max')[1]
return (mn, mx)
t = input()
t = int(t)
for k in range(t):
n = input()
n = int(n)
l = list(range(1, n+1))
mn, mx = find_min_max(l)
print("! {} {}".format(mn, mx))
sys.stdout.flush()
``` | instruction | 0 | 88,026 | 12 | 176,052 |
Yes | output | 1 | 88,026 | 12 | 176,053 |
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 have to use flush operation right after printing each line. For example, in C++ you should use function fflush(stdout), in Java — System.out.flush(), in Pascal — flush(output) and in Python — sys.stdout.flush().
In this problem, you need to find maximal and minimal elements of an array. What could be simpler?
You can imagine that the jury has an array, and initially you know the only number n — array's length.
Array's elements are numbered from 1 to n. You are allowed to compare two elements of the array by using their indices i and j. There are three possible responses to this query: '<' (if ai is less than aj), '=' (if ai is equal to aj) and finally '>' (if ai is greater than aj).
It's known that it's always possible to find both maximal and minimal elements of the array by using no more than <image> comparisons, where ⌈ x⌉ is the result of rounding x up.
Write the program that will find positions of the minimum and the maximum in the jury's array of length n, by using no more than f(n) comparisons.
Interaction
Each test for this problem will contain one or more arrays. You have to find positions of minimal and maximal elements for each of these arrays. The first line of the input contains integer T (1 ≤ T ≤ 1000) — number of arrays in the test.
Thus, at the beginning, you program should read number T, and then it should solve the problem for T jury's arrays one by one.
Then input for each array goes. Firstly, your program has to read the number n (1 ≤ n ≤ 50) — the length of the array. It will be provided in the next line of the input.
Further, your program can perform comparisons or report that the answer is found.
* To perform a comparison, you have to output string of the following pattern «? i j» (i and j must be integer numbers from 1 to n) — the indices of the elements to compare in the current query.
* To report the indices of minimal and maximal elements of the hidden array, your program have to output a line in the form «! i j» (i and j must be integer numbers from 1 to n), where i is an index of the minimal element of array, and j is an index of the maximal element of the array. If there are several possible answers to the problem, you can output any of them.
There are several possible responses for a comparison:
* '<' — if ai is less than aj,
* '=' — if ai is equal to aj,
* '>' — if ai is greater than aj.
For an array of length n your program can make at most <image> comparisons. Note that the operation of reporting an answer («! i j» ) is not included into the value of f(n).
After the answer is reported, your program has to solve the problem for the next array or it should terminate if all T arrays are processed.
Example
Input
2
2
>
3
=
=
Output
? 1 2
! 2 1
? 3 1
? 2 1
! 2 3
Submitted Solution:
```
# ---------------------------iye ha aam zindegi---------------------------------------------
import math
import heapq, bisect
import sys
from collections import deque, defaultdict
from fractions import Fraction
import sys
mod = 10 ** 9 + 7
mod1 = 998244353
# sys.setrecursionlimit(300000)
# ------------------------------warmup----------------------------
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
# sys.setrecursionlimit(300000)
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
# -----------------------------------------------binary seacrh tree---------------------------------------
# -------------------game starts now----------------------------------------------------import math
class SegmentTree:
def __init__(self, data, default=0, 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)
# -------------------------------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------------------------------------
for ik in range(int(input())):
n=int(input())
if n==1:
print("! 1 1",flush=True)
continue
elif n==2:
print("? 1 2",flush=True)
s=input()
if s==">":
print("! 2 1",flush=True)
else:
print("! 1 2",flush=True)
continue
last=1
f=2
res=[]
d=defaultdict(str)
for i in range(n-1):
#print("?",last,f,flush=True)
if (last,f) in d:
r=d[(last,f)]
elif (f,last) in d:
if d[(f,last)]==">":
r="<"
elif d[(f,last)]=="<":
r=">"
else:
r=d[(f,last)]
d[(f,last)]=r
else:
print("?", last, f, flush=True)
r=input()
d[(last,f)]=r
if r=='<':
res.append(last)
last=f
f+=1
else:
f+=1
res.append(f-1)
#print(res,d)
last1=res[0]
f1=res[1]
t=1
for i in range(len(res)-1):
if (last1,f1) in d:
r=d[(last1,f1)]
elif (f1,last1) in d:
if d[(f1,last1)]==">":
r="<"
elif d[(f1,last1)]=="<":
r=">"
else:
r=d[(f1,last1)]
else:
print("?", last1, f1, flush=True)
r = input()
d[(last1, f1)] = r
if r == '>':
res.append(last)
last = f1
if t+1==len(res):
break
f1= res[t+1]
t+=1
else:
if t+1==len(res):
break
f1 = res[t + 1]
t += 1
res.append(res[t-1])
print('!',last1,last,flush=True)
``` | instruction | 0 | 88,027 | 12 | 176,054 |
No | output | 1 | 88,027 | 12 | 176,055 |
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 have to use flush operation right after printing each line. For example, in C++ you should use function fflush(stdout), in Java — System.out.flush(), in Pascal — flush(output) and in Python — sys.stdout.flush().
In this problem, you need to find maximal and minimal elements of an array. What could be simpler?
You can imagine that the jury has an array, and initially you know the only number n — array's length.
Array's elements are numbered from 1 to n. You are allowed to compare two elements of the array by using their indices i and j. There are three possible responses to this query: '<' (if ai is less than aj), '=' (if ai is equal to aj) and finally '>' (if ai is greater than aj).
It's known that it's always possible to find both maximal and minimal elements of the array by using no more than <image> comparisons, where ⌈ x⌉ is the result of rounding x up.
Write the program that will find positions of the minimum and the maximum in the jury's array of length n, by using no more than f(n) comparisons.
Interaction
Each test for this problem will contain one or more arrays. You have to find positions of minimal and maximal elements for each of these arrays. The first line of the input contains integer T (1 ≤ T ≤ 1000) — number of arrays in the test.
Thus, at the beginning, you program should read number T, and then it should solve the problem for T jury's arrays one by one.
Then input for each array goes. Firstly, your program has to read the number n (1 ≤ n ≤ 50) — the length of the array. It will be provided in the next line of the input.
Further, your program can perform comparisons or report that the answer is found.
* To perform a comparison, you have to output string of the following pattern «? i j» (i and j must be integer numbers from 1 to n) — the indices of the elements to compare in the current query.
* To report the indices of minimal and maximal elements of the hidden array, your program have to output a line in the form «! i j» (i and j must be integer numbers from 1 to n), where i is an index of the minimal element of array, and j is an index of the maximal element of the array. If there are several possible answers to the problem, you can output any of them.
There are several possible responses for a comparison:
* '<' — if ai is less than aj,
* '=' — if ai is equal to aj,
* '>' — if ai is greater than aj.
For an array of length n your program can make at most <image> comparisons. Note that the operation of reporting an answer («! i j» ) is not included into the value of f(n).
After the answer is reported, your program has to solve the problem for the next array or it should terminate if all T arrays are processed.
Example
Input
2
2
>
3
=
=
Output
? 1 2
! 2 1
? 3 1
? 2 1
! 2 3
Submitted Solution:
```
import random
import sys
def myprint(s):
print(s)
sys.stdout.flush()
t = int(input())
while t > 0:
t -= 1
n = int(input())
A = [i+1 for i in range(n)]
allowed = 3 * n // 2 + n % 2 - 2
#print(allowed)
random.shuffle(A)
#print(A)
mx = 0
mn = 0
min_eq_max = True
def cmp(x, y):
myprint("? " + str(A[x]) + " " + str(A[y]))
return input()
for i in range(1, n):
withmin = ' '
if allowed:
withmin = cmp(i, mn)
allowed -= 1
if withmin == '<':
mn = i
min_eq_max = False
elif withmin == '=':
pass
elif allowed:
withmax = ' '
if min_eq_max:
withmax = withmin
else:
withmax = cmp(i, mx)
allowed -= 1
if withmax == '>':
mx = i
#print(A[mn], A[mx])
#myprint(allowed)
myprint("! "+ str(A[mn]) + " " + str(A[mx]))
``` | instruction | 0 | 88,028 | 12 | 176,056 |
No | output | 1 | 88,028 | 12 | 176,057 |
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 have to use flush operation right after printing each line. For example, in C++ you should use function fflush(stdout), in Java — System.out.flush(), in Pascal — flush(output) and in Python — sys.stdout.flush().
In this problem, you need to find maximal and minimal elements of an array. What could be simpler?
You can imagine that the jury has an array, and initially you know the only number n — array's length.
Array's elements are numbered from 1 to n. You are allowed to compare two elements of the array by using their indices i and j. There are three possible responses to this query: '<' (if ai is less than aj), '=' (if ai is equal to aj) and finally '>' (if ai is greater than aj).
It's known that it's always possible to find both maximal and minimal elements of the array by using no more than <image> comparisons, where ⌈ x⌉ is the result of rounding x up.
Write the program that will find positions of the minimum and the maximum in the jury's array of length n, by using no more than f(n) comparisons.
Interaction
Each test for this problem will contain one or more arrays. You have to find positions of minimal and maximal elements for each of these arrays. The first line of the input contains integer T (1 ≤ T ≤ 1000) — number of arrays in the test.
Thus, at the beginning, you program should read number T, and then it should solve the problem for T jury's arrays one by one.
Then input for each array goes. Firstly, your program has to read the number n (1 ≤ n ≤ 50) — the length of the array. It will be provided in the next line of the input.
Further, your program can perform comparisons or report that the answer is found.
* To perform a comparison, you have to output string of the following pattern «? i j» (i and j must be integer numbers from 1 to n) — the indices of the elements to compare in the current query.
* To report the indices of minimal and maximal elements of the hidden array, your program have to output a line in the form «! i j» (i and j must be integer numbers from 1 to n), where i is an index of the minimal element of array, and j is an index of the maximal element of the array. If there are several possible answers to the problem, you can output any of them.
There are several possible responses for a comparison:
* '<' — if ai is less than aj,
* '=' — if ai is equal to aj,
* '>' — if ai is greater than aj.
For an array of length n your program can make at most <image> comparisons. Note that the operation of reporting an answer («! i j» ) is not included into the value of f(n).
After the answer is reported, your program has to solve the problem for the next array or it should terminate if all T arrays are processed.
Example
Input
2
2
>
3
=
=
Output
? 1 2
! 2 1
? 3 1
? 2 1
! 2 3
Submitted Solution:
```
import sys
T = int(input())
def compare(l,r,arr):
print('?',a[l]+1,a[r]+1)
sys.stdout.flush()
res = input()
if (res == '>'): return 1;
else: return 0;
while (T > 0):
T -= 1
Max_a = []
Min_a = []
n = int(input())
a = range(n)
for i in range(int(n/2)):
if (compare(i*2,i*2+1,a) > 0):
Max_a.append(i*2)
Min_a.append(i*2+1)
else :
Max_a.append(i*2+1)
Min_a.append(i*2)
if (n%2 == 1):Max_a.append(n-1)
Max_index = Max_a[-1]
Min_index = Min_a[-1]
for i in range(len(Max_a)-1):
if (compare(Max_a[i],Max_index,a) > 0):
Max_index = Max_a[i]
for i in range(len(Min_a)-1):
if (compare(Min_a[i],Min_index,a) == 0):
Min_index = Min_a[i]
print('!',Min_index+1,Max_index+1)
sys.stdout.flush()
``` | instruction | 0 | 88,029 | 12 | 176,058 |
No | output | 1 | 88,029 | 12 | 176,059 |
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 have to use flush operation right after printing each line. For example, in C++ you should use function fflush(stdout), in Java — System.out.flush(), in Pascal — flush(output) and in Python — sys.stdout.flush().
In this problem, you need to find maximal and minimal elements of an array. What could be simpler?
You can imagine that the jury has an array, and initially you know the only number n — array's length.
Array's elements are numbered from 1 to n. You are allowed to compare two elements of the array by using their indices i and j. There are three possible responses to this query: '<' (if ai is less than aj), '=' (if ai is equal to aj) and finally '>' (if ai is greater than aj).
It's known that it's always possible to find both maximal and minimal elements of the array by using no more than <image> comparisons, where ⌈ x⌉ is the result of rounding x up.
Write the program that will find positions of the minimum and the maximum in the jury's array of length n, by using no more than f(n) comparisons.
Interaction
Each test for this problem will contain one or more arrays. You have to find positions of minimal and maximal elements for each of these arrays. The first line of the input contains integer T (1 ≤ T ≤ 1000) — number of arrays in the test.
Thus, at the beginning, you program should read number T, and then it should solve the problem for T jury's arrays one by one.
Then input for each array goes. Firstly, your program has to read the number n (1 ≤ n ≤ 50) — the length of the array. It will be provided in the next line of the input.
Further, your program can perform comparisons or report that the answer is found.
* To perform a comparison, you have to output string of the following pattern «? i j» (i and j must be integer numbers from 1 to n) — the indices of the elements to compare in the current query.
* To report the indices of minimal and maximal elements of the hidden array, your program have to output a line in the form «! i j» (i and j must be integer numbers from 1 to n), where i is an index of the minimal element of array, and j is an index of the maximal element of the array. If there are several possible answers to the problem, you can output any of them.
There are several possible responses for a comparison:
* '<' — if ai is less than aj,
* '=' — if ai is equal to aj,
* '>' — if ai is greater than aj.
For an array of length n your program can make at most <image> comparisons. Note that the operation of reporting an answer («! i j» ) is not included into the value of f(n).
After the answer is reported, your program has to solve the problem for the next array or it should terminate if all T arrays are processed.
Example
Input
2
2
>
3
=
=
Output
? 1 2
! 2 1
? 3 1
? 2 1
! 2 3
Submitted Solution:
```
from sys import stdin, stdout
from math import sin, tan, cos
def ask(i, j):
stdout.write(str(i) + ' ' + str(j) + '\n')
stdout.flush()
return stdin.readline().strip()
T = int(stdin.readline())
for t in range(T):
n = int(stdin.readline())
if n == 1:
stdout.write('! 1 1\n')
stdout.flush()
continue
l, r = 1, 2
if ask(l, r) == '>':
l, r = r, l
for i in range(3, n + 1, 2):
if i == n:
s = ask(l, i)
f = ask(r, i)
if s == '>':
l = i
if f == '<':
r = i
continue
lb, rb = i, i + 1
if ask(lb, rb) == '>':
lb, rb = rb, lb
if ask(lb, l) == '<':
l = lb
if ask(rb, r) == '>':
r = rb
stdout.write('! ' + str(l) + ' ' + str(r) + '\n')
stdout.flush()
``` | instruction | 0 | 88,030 | 12 | 176,060 |
No | output | 1 | 88,030 | 12 | 176,061 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Given an array a1, a2, ..., an of n integers, find the largest number in the array that is not a perfect square.
A number x is said to be a perfect square if there exists an integer y such that x = y2.
Input
The first line contains a single integer n (1 ≤ n ≤ 1000) — the number of elements in the array.
The second line contains n integers a1, a2, ..., an ( - 106 ≤ ai ≤ 106) — the elements of the array.
It is guaranteed that at least one element of the array is not a perfect square.
Output
Print the largest number in the array which is not a perfect square. It is guaranteed that an answer always exists.
Examples
Input
2
4 2
Output
2
Input
8
1 2 4 8 16 32 64 576
Output
32
Note
In the first sample case, 4 is a perfect square, so the largest number in the array that is not a perfect square is 2. | instruction | 0 | 88,083 | 12 | 176,166 |
Tags: brute force, implementation, math
Correct Solution:
```
n = int(input())
a = [int(i)for i in input().split()]
a = sorted(a)
max_ = 0
for i in range(n):
if a[i] >= 0:
if a[i]**0.5 != int(a[i]**0.5):
max_ = a[i]
if max_ != 0:
print(max_)
else:
for i in range(n):
if a[i] < 0:
max_ = a[i]
print(max_)
``` | output | 1 | 88,083 | 12 | 176,167 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Given an array a1, a2, ..., an of n integers, find the largest number in the array that is not a perfect square.
A number x is said to be a perfect square if there exists an integer y such that x = y2.
Input
The first line contains a single integer n (1 ≤ n ≤ 1000) — the number of elements in the array.
The second line contains n integers a1, a2, ..., an ( - 106 ≤ ai ≤ 106) — the elements of the array.
It is guaranteed that at least one element of the array is not a perfect square.
Output
Print the largest number in the array which is not a perfect square. It is guaranteed that an answer always exists.
Examples
Input
2
4 2
Output
2
Input
8
1 2 4 8 16 32 64 576
Output
32
Note
In the first sample case, 4 is a perfect square, so the largest number in the array that is not a perfect square is 2. | instruction | 0 | 88,084 | 12 | 176,168 |
Tags: brute force, implementation, math
Correct Solution:
```
import math
n = int(input())
p = list(map(int, input().split()))
def s(n, p):
if n == 1:
print(p[0])
return
elif max(p) < 0:
print(max(p))
return
while math.sqrt(max(p)) == int(math.sqrt(max(p))):
p.remove(max(p))
if max(p) < 0:
print(max(p))
return
print(max(p))
s(n, p)
``` | output | 1 | 88,084 | 12 | 176,169 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Given an array a1, a2, ..., an of n integers, find the largest number in the array that is not a perfect square.
A number x is said to be a perfect square if there exists an integer y such that x = y2.
Input
The first line contains a single integer n (1 ≤ n ≤ 1000) — the number of elements in the array.
The second line contains n integers a1, a2, ..., an ( - 106 ≤ ai ≤ 106) — the elements of the array.
It is guaranteed that at least one element of the array is not a perfect square.
Output
Print the largest number in the array which is not a perfect square. It is guaranteed that an answer always exists.
Examples
Input
2
4 2
Output
2
Input
8
1 2 4 8 16 32 64 576
Output
32
Note
In the first sample case, 4 is a perfect square, so the largest number in the array that is not a perfect square is 2. | instruction | 0 | 88,085 | 12 | 176,170 |
Tags: brute force, implementation, math
Correct Solution:
```
import math
x=int(input())
l=list(map(int,input().split()))
k={}
for i in l:
k[i]=(abs(i)**0.5)
f=[]
for i in l:
if i<0:
f.append(i)
for i in k.keys():
if k[i]%1==0:
pass
else:
f.append(i)
print(max(f))
``` | output | 1 | 88,085 | 12 | 176,171 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Given an array a1, a2, ..., an of n integers, find the largest number in the array that is not a perfect square.
A number x is said to be a perfect square if there exists an integer y such that x = y2.
Input
The first line contains a single integer n (1 ≤ n ≤ 1000) — the number of elements in the array.
The second line contains n integers a1, a2, ..., an ( - 106 ≤ ai ≤ 106) — the elements of the array.
It is guaranteed that at least one element of the array is not a perfect square.
Output
Print the largest number in the array which is not a perfect square. It is guaranteed that an answer always exists.
Examples
Input
2
4 2
Output
2
Input
8
1 2 4 8 16 32 64 576
Output
32
Note
In the first sample case, 4 is a perfect square, so the largest number in the array that is not a perfect square is 2. | instruction | 0 | 88,086 | 12 | 176,172 |
Tags: brute force, implementation, math
Correct Solution:
```
from math import sqrt
n = int(input())
l = list(map(int,input().split()))
max1=-float("inf")
for i in range(n):
if l[i]<0 or (sqrt(l[i]))!=int(sqrt(l[i])):
if l[i]>max1:
max1=l[i]
print(max1)
``` | output | 1 | 88,086 | 12 | 176,173 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Given an array a1, a2, ..., an of n integers, find the largest number in the array that is not a perfect square.
A number x is said to be a perfect square if there exists an integer y such that x = y2.
Input
The first line contains a single integer n (1 ≤ n ≤ 1000) — the number of elements in the array.
The second line contains n integers a1, a2, ..., an ( - 106 ≤ ai ≤ 106) — the elements of the array.
It is guaranteed that at least one element of the array is not a perfect square.
Output
Print the largest number in the array which is not a perfect square. It is guaranteed that an answer always exists.
Examples
Input
2
4 2
Output
2
Input
8
1 2 4 8 16 32 64 576
Output
32
Note
In the first sample case, 4 is a perfect square, so the largest number in the array that is not a perfect square is 2. | instruction | 0 | 88,087 | 12 | 176,174 |
Tags: brute force, implementation, math
Correct Solution:
```
from math import sqrt, floor
int(input())
for n in sorted(map(int, input().split()))[::-1]:
if abs(n) != n:
print(n)
break
elif floor(sqrt(n)) - sqrt(n) != 0:
print(n)
break
``` | output | 1 | 88,087 | 12 | 176,175 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Given an array a1, a2, ..., an of n integers, find the largest number in the array that is not a perfect square.
A number x is said to be a perfect square if there exists an integer y such that x = y2.
Input
The first line contains a single integer n (1 ≤ n ≤ 1000) — the number of elements in the array.
The second line contains n integers a1, a2, ..., an ( - 106 ≤ ai ≤ 106) — the elements of the array.
It is guaranteed that at least one element of the array is not a perfect square.
Output
Print the largest number in the array which is not a perfect square. It is guaranteed that an answer always exists.
Examples
Input
2
4 2
Output
2
Input
8
1 2 4 8 16 32 64 576
Output
32
Note
In the first sample case, 4 is a perfect square, so the largest number in the array that is not a perfect square is 2. | instruction | 0 | 88,088 | 12 | 176,176 |
Tags: brute force, implementation, math
Correct Solution:
```
import math
n=int(input())
x=list(map(int,input().split()))
#arr=sorted(x)
count=-1000001
for i in range(n):
if((x[i]<0) or (math.sqrt(x[i])!=int(math.sqrt(x[i])))):
count=max(count,x[i])
print(count)
``` | output | 1 | 88,088 | 12 | 176,177 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Given an array a1, a2, ..., an of n integers, find the largest number in the array that is not a perfect square.
A number x is said to be a perfect square if there exists an integer y such that x = y2.
Input
The first line contains a single integer n (1 ≤ n ≤ 1000) — the number of elements in the array.
The second line contains n integers a1, a2, ..., an ( - 106 ≤ ai ≤ 106) — the elements of the array.
It is guaranteed that at least one element of the array is not a perfect square.
Output
Print the largest number in the array which is not a perfect square. It is guaranteed that an answer always exists.
Examples
Input
2
4 2
Output
2
Input
8
1 2 4 8 16 32 64 576
Output
32
Note
In the first sample case, 4 is a perfect square, so the largest number in the array that is not a perfect square is 2. | instruction | 0 | 88,089 | 12 | 176,178 |
Tags: brute force, implementation, math
Correct Solution:
```
import math
def perfect_square(x):
if x<0:
return False
else:
y=x**(1/2)
if y-math.floor(y)==0.0:
return True
not_perfect_square_list=[]
n=int(input())
if 1<=n<=1000:
lis=list(map(int,input().split()))
if len(lis)==n:
for i in lis:
if perfect_square(i):
continue
else:
not_perfect_square_list.append(i)
else:
exit()
print(max(not_perfect_square_list))
else:
exit()
``` | output | 1 | 88,089 | 12 | 176,179 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Given an array a1, a2, ..., an of n integers, find the largest number in the array that is not a perfect square.
A number x is said to be a perfect square if there exists an integer y such that x = y2.
Input
The first line contains a single integer n (1 ≤ n ≤ 1000) — the number of elements in the array.
The second line contains n integers a1, a2, ..., an ( - 106 ≤ ai ≤ 106) — the elements of the array.
It is guaranteed that at least one element of the array is not a perfect square.
Output
Print the largest number in the array which is not a perfect square. It is guaranteed that an answer always exists.
Examples
Input
2
4 2
Output
2
Input
8
1 2 4 8 16 32 64 576
Output
32
Note
In the first sample case, 4 is a perfect square, so the largest number in the array that is not a perfect square is 2. | instruction | 0 | 88,090 | 12 | 176,180 |
Tags: brute force, implementation, math
Correct Solution:
```
n = int(input())
a = list(map(int, input().split()))
s = {i*i for i in range(1001)}
print(max([i for i in a if i not in s]))
``` | output | 1 | 88,090 | 12 | 176,181 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given an array a1, a2, ..., an of n integers, find the largest number in the array that is not a perfect square.
A number x is said to be a perfect square if there exists an integer y such that x = y2.
Input
The first line contains a single integer n (1 ≤ n ≤ 1000) — the number of elements in the array.
The second line contains n integers a1, a2, ..., an ( - 106 ≤ ai ≤ 106) — the elements of the array.
It is guaranteed that at least one element of the array is not a perfect square.
Output
Print the largest number in the array which is not a perfect square. It is guaranteed that an answer always exists.
Examples
Input
2
4 2
Output
2
Input
8
1 2 4 8 16 32 64 576
Output
32
Note
In the first sample case, 4 is a perfect square, so the largest number in the array that is not a perfect square is 2.
Submitted Solution:
```
z=input
mod = 10**9 + 7
from collections import *
from queue import *
from sys import *
from collections import *
from math import *
from heapq import *
from itertools import *
from bisect import *
from collections import Counter as cc
from math import factorial as f
def lcd(xnum1,xnum2):
return (xnum1*xnum2//gcd(xnum1,xnum2))
################################################################################
"""
n=int(z())
for _ in range(int(z())):
x=int(z())
l=list(map(int,z().split()))
n=int(z())
l=sorted(list(map(int,z().split())))[::-1]
a,b=map(int,z().split())
l=set(map(int,z().split()))
led=(6,2,5,5,4,5,6,3,7,6)
vowel={'a':0,'e':0,'i':0,'o':0,'u':0}
color-4=["G", "GB", "YGB", "YGBI", "OYGBI" ,"OYGBIV",'ROYGBIV' ]
"""
###########################---START-CODING---###############################################
n=int(z())
l=sorted(list(map(int,z().split())))[::-1]
for i in l:
t=i
if i<0:
i=i*-1
print(t)
exit()
if int(i**.5)!=i**.5:
print(t)
exit(0)
``` | instruction | 0 | 88,092 | 12 | 176,184 |
Yes | output | 1 | 88,092 | 12 | 176,185 |
Provide tags and a correct Python 3 solution for this coding contest problem.
We guessed a permutation p consisting of n integers. The permutation of length n is the array of length n where each element from 1 to n appears exactly once. This permutation is a secret for you.
For each position r from 2 to n we chose some other index l (l < r) and gave you the segment p_l, p_{l + 1}, ..., p_r in sorted order (i.e. we rearranged the elements of this segment in a way that the elements of this segment are sorted). Thus, you are given exactly n-1 segments of the initial permutation but elements inside each segment are sorted. The segments are given to you in random order.
For example, if the secret permutation is p=[3, 1, 4, 6, 2, 5] then the possible given set of segments can be:
* [2, 5, 6]
* [4, 6]
* [1, 3, 4]
* [1, 3]
* [1, 2, 4, 6]
Your task is to find any suitable permutation (i.e. any permutation corresponding to the given input data). It is guaranteed that the input data corresponds to some permutation (i.e. such permutation exists).
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (2 ≤ n ≤ 200) — the length of the permutation.
The next n-1 lines describe given segments.
The i-th line contains the description of the i-th segment. The line starts with the integer k_i (2 ≤ k_i ≤ n) — the length of the i-th segment. Then k_i integers follow. All integers in a line are distinct, sorted in ascending order, between 1 and n, inclusive.
It is guaranteed that the required p exists for each test case.
It is also guaranteed that the sum of n over all test cases does not exceed 200 (∑ n ≤ 200).
Output
For each test case, print the answer: n integers p_1, p_2, ..., p_n (1 ≤ p_i ≤ n, all p_i should be distinct) — any suitable permutation (i.e. any permutation corresponding to the test case input).
Example
Input
5
6
3 2 5 6
2 4 6
3 1 3 4
2 1 3
4 1 2 4 6
5
2 2 3
2 1 2
2 1 4
2 4 5
7
3 1 2 6
4 1 3 5 6
2 1 2
3 4 5 7
6 1 2 3 4 5 6
3 1 3 6
2
2 1 2
5
2 2 5
3 2 3 5
4 2 3 4 5
5 1 2 3 4 5
Output
3 1 4 6 2 5
3 2 1 4 5
2 1 6 3 5 4 7
1 2
2 5 3 4 1 | instruction | 0 | 88,543 | 12 | 177,086 |
Tags: brute force, constructive algorithms, data structures, greedy, implementation
Correct Solution:
```
import copy
t = int(input())
def fn(ivs, v, n):
result = list()
while len(result) < n - 1:
w = None
for iv in ivs:
if v in iv:
iv.remove(v)
if len(iv) == 1:
if w is None:
w = iv.pop()
else:
return
if w is None:
return
result.append(v)
v = w
result.append(v)
return result
def check(res, sivs, n):
if res is None:
return False
for i in range(1, n):
good = False
for j in range(i):
if tuple(sorted(res[j:i + 1])) in sivs:
good = True
if not good:
return False
return True
for _ in range(t):
n = int(input())
ivs = list()
for _ in range(n - 1):
ivs.append(set(map(int, input().split(' ')[1:])))
sivs = set()
for iv in ivs:
sivs.add(tuple(iv))
for v in range(1, n + 1):
res = fn(copy.deepcopy(ivs), v, n)
if check(res, sivs, n):
print(' '.join(map(str, res)))
break
``` | output | 1 | 88,543 | 12 | 177,087 |
Provide tags and a correct Python 3 solution for this coding contest problem.
We guessed a permutation p consisting of n integers. The permutation of length n is the array of length n where each element from 1 to n appears exactly once. This permutation is a secret for you.
For each position r from 2 to n we chose some other index l (l < r) and gave you the segment p_l, p_{l + 1}, ..., p_r in sorted order (i.e. we rearranged the elements of this segment in a way that the elements of this segment are sorted). Thus, you are given exactly n-1 segments of the initial permutation but elements inside each segment are sorted. The segments are given to you in random order.
For example, if the secret permutation is p=[3, 1, 4, 6, 2, 5] then the possible given set of segments can be:
* [2, 5, 6]
* [4, 6]
* [1, 3, 4]
* [1, 3]
* [1, 2, 4, 6]
Your task is to find any suitable permutation (i.e. any permutation corresponding to the given input data). It is guaranteed that the input data corresponds to some permutation (i.e. such permutation exists).
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (2 ≤ n ≤ 200) — the length of the permutation.
The next n-1 lines describe given segments.
The i-th line contains the description of the i-th segment. The line starts with the integer k_i (2 ≤ k_i ≤ n) — the length of the i-th segment. Then k_i integers follow. All integers in a line are distinct, sorted in ascending order, between 1 and n, inclusive.
It is guaranteed that the required p exists for each test case.
It is also guaranteed that the sum of n over all test cases does not exceed 200 (∑ n ≤ 200).
Output
For each test case, print the answer: n integers p_1, p_2, ..., p_n (1 ≤ p_i ≤ n, all p_i should be distinct) — any suitable permutation (i.e. any permutation corresponding to the test case input).
Example
Input
5
6
3 2 5 6
2 4 6
3 1 3 4
2 1 3
4 1 2 4 6
5
2 2 3
2 1 2
2 1 4
2 4 5
7
3 1 2 6
4 1 3 5 6
2 1 2
3 4 5 7
6 1 2 3 4 5 6
3 1 3 6
2
2 1 2
5
2 2 5
3 2 3 5
4 2 3 4 5
5 1 2 3 4 5
Output
3 1 4 6 2 5
3 2 1 4 5
2 1 6 3 5 4 7
1 2
2 5 3 4 1 | instruction | 0 | 88,544 | 12 | 177,088 |
Tags: brute force, constructive algorithms, data structures, greedy, implementation
Correct Solution:
```
import io
import os
from collections import defaultdict
from copy import deepcopy
def solve(N, segments):
def greedy(ans, memToSeg, first):
# If a number is only in a single segment, it's either the first or last element
# We need to be able to pick the last element for us to inductively remove a segment and look for the next element that is only contained in one segment
# If there's more than one candidate, try both as the potential first
# Initially our first is unconstrained
while len(memToSeg) > 2:
candidates = [k for k, v in memToSeg.items() if len(v) == 1 and k != first]
if len(candidates) != 1:
if len(candidates) == 0:
# If we found zero candidates, it means our choice of first is invalid
assert first is not None
return None
# Otherwise we found our candidates for first and last
assert len(candidates) == 2 and first is None
for c in candidates:
# Branch the greedy to try both cases. This will only happen once
temp = greedy(deepcopy(ans), deepcopy(memToSeg), first=c)
if temp is None:
continue
# Double check that our answer works
numToIndex = {x: i for i, x in enumerate(temp)}
bad = False
for segment in segments:
mn = min(numToIndex[x] for x in segment)
mx = max(numToIndex[x] for x in segment)
if mx - mn + 1 != len(segment):
bad = True
break
if not bad:
return temp
assert False
else:
# If we only had one candidate we can continue inductively removing it as the last element
assert len(candidates) == 1
(k,) = candidates
v = memToSeg[candidates[0]]
assert len(v) == 1
(index,) = v
ans.append(k)
for x in segments[index]:
memToSeg[x].remove(index)
if len(memToSeg[x]) == 0:
assert x == k
del memToSeg[x]
# In the very end we have a single segment left of length 2 and both remaining numbers point to it
firstTwo = []
assert len(memToSeg) == 2
for k, v in memToSeg.items():
assert len(v) == 1
firstTwo.append(k)
if first is not None:
assert first in firstTwo
if firstTwo[0] == first:
ans.append(firstTwo[1])
ans.append(firstTwo[0])
else:
ans.append(firstTwo[0])
ans.append(firstTwo[1])
else:
for segment in segments:
if firstTwo[0] in segment and firstTwo[1] not in segment:
ans.append(firstTwo[0])
ans.append(firstTwo[1])
break
if firstTwo[1] in segment and firstTwo[0] not in segment:
ans.append(firstTwo[1])
ans.append(firstTwo[0])
break
else:
ans.extend(firstTwo)
return ans
memToSeg = defaultdict(set)
for i, segment in enumerate(segments):
for x in segment:
memToSeg[x].add(i)
return " ".join(map(str, reversed(greedy([], memToSeg, None))))
if __name__ == "__main__":
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
T = int(input())
for t in range(T):
(N,) = [int(x) for x in input().split()]
segments = []
for i in range(N - 1):
segment = [int(x) for x in input().split()]
assert segment[0] == len(segment) - 1
segments.append(segment[1:])
ans = solve(N, segments)
print(ans)
``` | output | 1 | 88,544 | 12 | 177,089 |
Provide tags and a correct Python 3 solution for this coding contest problem.
We guessed a permutation p consisting of n integers. The permutation of length n is the array of length n where each element from 1 to n appears exactly once. This permutation is a secret for you.
For each position r from 2 to n we chose some other index l (l < r) and gave you the segment p_l, p_{l + 1}, ..., p_r in sorted order (i.e. we rearranged the elements of this segment in a way that the elements of this segment are sorted). Thus, you are given exactly n-1 segments of the initial permutation but elements inside each segment are sorted. The segments are given to you in random order.
For example, if the secret permutation is p=[3, 1, 4, 6, 2, 5] then the possible given set of segments can be:
* [2, 5, 6]
* [4, 6]
* [1, 3, 4]
* [1, 3]
* [1, 2, 4, 6]
Your task is to find any suitable permutation (i.e. any permutation corresponding to the given input data). It is guaranteed that the input data corresponds to some permutation (i.e. such permutation exists).
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (2 ≤ n ≤ 200) — the length of the permutation.
The next n-1 lines describe given segments.
The i-th line contains the description of the i-th segment. The line starts with the integer k_i (2 ≤ k_i ≤ n) — the length of the i-th segment. Then k_i integers follow. All integers in a line are distinct, sorted in ascending order, between 1 and n, inclusive.
It is guaranteed that the required p exists for each test case.
It is also guaranteed that the sum of n over all test cases does not exceed 200 (∑ n ≤ 200).
Output
For each test case, print the answer: n integers p_1, p_2, ..., p_n (1 ≤ p_i ≤ n, all p_i should be distinct) — any suitable permutation (i.e. any permutation corresponding to the test case input).
Example
Input
5
6
3 2 5 6
2 4 6
3 1 3 4
2 1 3
4 1 2 4 6
5
2 2 3
2 1 2
2 1 4
2 4 5
7
3 1 2 6
4 1 3 5 6
2 1 2
3 4 5 7
6 1 2 3 4 5 6
3 1 3 6
2
2 1 2
5
2 2 5
3 2 3 5
4 2 3 4 5
5 1 2 3 4 5
Output
3 1 4 6 2 5
3 2 1 4 5
2 1 6 3 5 4 7
1 2
2 5 3 4 1 | instruction | 0 | 88,545 | 12 | 177,090 |
Tags: brute force, constructive algorithms, data structures, greedy, implementation
Correct Solution:
```
from collections import Counter
from itertools import chain
def dfs(n, r, hint_sets, count, removed, result):
if len(result) == n - 1:
last = (set(range(1, n + 1)) - set(result)).pop()
result.append(last)
return True
i, including_r = 0, None
for i, including_r in enumerate(hint_sets):
if i in removed:
continue
if r in including_r:
break
removed.add(i)
next_r = []
for q in including_r:
count[q] -= 1
if count[q] == 1:
next_r.append(q)
if not next_r:
return False
if len(next_r) == 2:
nr = -1
can1, can2 = next_r
for i, h in enumerate(hint_sets):
if i not in removed:
continue
if can1 in h and can2 not in h:
nr = can1
break
if can1 not in h and can2 in h:
nr = can2
break
if nr == -1:
nr = can1
else:
nr = next_r[0]
result.append(nr)
res = dfs(n, nr, hint_sets, count, removed, result)
if res:
return True
result.pop()
for q in including_r:
count[q] += 1
return False
t = int(input())
buf = []
for l in range(t):
n = int(input())
hints = []
for _ in range(n - 1):
k, *ppp = map(int, input().split())
hints.append(ppp)
count = Counter(chain.from_iterable(hints))
most_common = count.most_common()
hint_sets = list(map(set, hints))
r = most_common[-1][0]
result = [r]
if dfs(n, r, hint_sets, dict(count), set(), result):
buf.append(' '.join(map(str, result[::-1])))
continue
r = most_common[-2][0]
result = [r]
assert dfs(n, r, hint_sets, dict(count), set(), result)
buf.append(' '.join(map(str, result[::-1])))
print('\n'.join(map(str, buf)))
``` | output | 1 | 88,545 | 12 | 177,091 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.