message stringlengths 2 48.6k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 318 108k | cluster float64 8 8 | __index_level_0__ int64 636 217k |
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
This year in Equestria was a year of plenty, so Applejack has decided to build some new apple storages. According to the advice of the farm designers, she chose to build two storages with non-zero area: one in the shape of a square and another one in the shape of a rectangle (which possibly can be a square as well).
Applejack will build the storages using planks, she is going to spend exactly one plank on each side of the storage. She can get planks from her friend's company. Initially, the company storehouse has n planks, Applejack knows their lengths. The company keeps working so it receives orders and orders the planks itself. Applejack's friend can provide her with information about each operation. For convenience, he will give her information according to the following format:
* + x: the storehouse received a plank with length x
* - x: one plank with length x was removed from the storehouse (it is guaranteed that the storehouse had some planks with length x).
Applejack is still unsure about when she is going to order the planks so she wants to know if she can order the planks to build rectangular and square storages out of them after every event at the storehouse. Applejack is busy collecting apples and she has completely no time to do the calculations so she asked you for help!
We remind you that all four sides of a square are equal, and a rectangle has two pairs of equal sides.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^5): the initial amount of planks at the company's storehouse, the second line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^5): the lengths of the planks.
The third line contains a single integer q (1 ≤ q ≤ 10^5): the number of events in the company. Each of the next q lines contains a description of the events in a given format: the type of the event (a symbol + or -) is given first, then goes the integer x (1 ≤ x ≤ 10^5).
Output
After every event in the company, print "YES" if two storages of the required shape can be built from the planks of that company's set, and print "NO" otherwise. You can print each letter in any case (upper or lower).
Example
Input
6
1 1 1 2 1 1
6
+ 2
+ 1
- 1
+ 2
- 1
+ 2
Output
NO
YES
NO
NO
NO
YES
Note
After the second event Applejack can build a rectangular storage using planks with lengths 1, 2, 1, 2 and a square storage using planks with lengths 1, 1, 1, 1.
After the sixth event Applejack can build a rectangular storage using planks with lengths 2, 2, 2, 2 and a square storage using planks with lengths 1, 1, 1, 1. | instruction | 0 | 51,523 | 8 | 103,046 |
Tags: constructive algorithms, data structures, greedy, implementation
Correct Solution:
```
n=int(input())
arr=list(map(int,input().split()))
ct=dict()
for k in arr:
if(k not in ct):
ct[k]=0
ct[k]+=1
fr=0;tw=0
for i in ct:
fr+=ct[i]//4
tw+=(ct[i]%4)//2
t=int(input())
for i in range(t):
p=input()
if(p[0]=="+"):
k=int(p[1:])
if(k not in ct):
ct[k]=1
else:
r =ct[k]//4
w = (ct[k]%4)//2
ct[k]+=1
if (ct[k]//4>r):
fr += 1
if ((ct[k]%4)//2>w):
tw += 1
if (ct[k] // 4 < r):
fr -= 1
if ((ct[k] % 4) // 2 < w):
tw -= 1
else:
k=int(p[1:])
r = ct[k] // 4
w = (ct[k] % 4) // 2
ct[k] -= 1
if (ct[k] // 4 < r):
fr -= 1
if ((ct[k] % 4) // 2 < w):
tw -= 1
if (ct[k] // 4 > r):
fr += 1
if ((ct[k] % 4) // 2 > w):
tw += 1
if(fr>=2):
print("YES")
elif(fr>=1 and tw>=2):
print("YES")
else:
print("NO")
``` | output | 1 | 51,523 | 8 | 103,047 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This year in Equestria was a year of plenty, so Applejack has decided to build some new apple storages. According to the advice of the farm designers, she chose to build two storages with non-zero area: one in the shape of a square and another one in the shape of a rectangle (which possibly can be a square as well).
Applejack will build the storages using planks, she is going to spend exactly one plank on each side of the storage. She can get planks from her friend's company. Initially, the company storehouse has n planks, Applejack knows their lengths. The company keeps working so it receives orders and orders the planks itself. Applejack's friend can provide her with information about each operation. For convenience, he will give her information according to the following format:
* + x: the storehouse received a plank with length x
* - x: one plank with length x was removed from the storehouse (it is guaranteed that the storehouse had some planks with length x).
Applejack is still unsure about when she is going to order the planks so she wants to know if she can order the planks to build rectangular and square storages out of them after every event at the storehouse. Applejack is busy collecting apples and she has completely no time to do the calculations so she asked you for help!
We remind you that all four sides of a square are equal, and a rectangle has two pairs of equal sides.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^5): the initial amount of planks at the company's storehouse, the second line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^5): the lengths of the planks.
The third line contains a single integer q (1 ≤ q ≤ 10^5): the number of events in the company. Each of the next q lines contains a description of the events in a given format: the type of the event (a symbol + or -) is given first, then goes the integer x (1 ≤ x ≤ 10^5).
Output
After every event in the company, print "YES" if two storages of the required shape can be built from the planks of that company's set, and print "NO" otherwise. You can print each letter in any case (upper or lower).
Example
Input
6
1 1 1 2 1 1
6
+ 2
+ 1
- 1
+ 2
- 1
+ 2
Output
NO
YES
NO
NO
NO
YES
Note
After the second event Applejack can build a rectangular storage using planks with lengths 1, 2, 1, 2 and a square storage using planks with lengths 1, 1, 1, 1.
After the sixth event Applejack can build a rectangular storage using planks with lengths 2, 2, 2, 2 and a square storage using planks with lengths 1, 1, 1, 1. | instruction | 0 | 51,524 | 8 | 103,048 |
Tags: constructive algorithms, data structures, greedy, implementation
Correct Solution:
```
n = int(input())
a = list(map(int, input().split(' ')))
numP = 0
sqr = 0
cnt = [0] * 100010
for x in a:
cnt[x] += 1
if (cnt[x] % 2 == 0):
numP += 1
if (cnt[x] == 4):
sqr += 1
q = int(input())
for i in range(q):
inp = input().split(' ')
c = inp[0]
x = int(inp[1])
if (c == '+'):
cnt[x] += 1
if (cnt[x] % 2 == 0):
numP += 1
if (cnt[x] == 4):
sqr += 1
else:
cnt[x] -= 1
if (cnt[x] % 2 == 1):
numP -= 1
if (cnt[x] == 3):
sqr -= 1
if (sqr == 0 or numP - 2 < 2):
print('NO\n')
else:
print('YES\n')
``` | output | 1 | 51,524 | 8 | 103,049 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This year in Equestria was a year of plenty, so Applejack has decided to build some new apple storages. According to the advice of the farm designers, she chose to build two storages with non-zero area: one in the shape of a square and another one in the shape of a rectangle (which possibly can be a square as well).
Applejack will build the storages using planks, she is going to spend exactly one plank on each side of the storage. She can get planks from her friend's company. Initially, the company storehouse has n planks, Applejack knows their lengths. The company keeps working so it receives orders and orders the planks itself. Applejack's friend can provide her with information about each operation. For convenience, he will give her information according to the following format:
* + x: the storehouse received a plank with length x
* - x: one plank with length x was removed from the storehouse (it is guaranteed that the storehouse had some planks with length x).
Applejack is still unsure about when she is going to order the planks so she wants to know if she can order the planks to build rectangular and square storages out of them after every event at the storehouse. Applejack is busy collecting apples and she has completely no time to do the calculations so she asked you for help!
We remind you that all four sides of a square are equal, and a rectangle has two pairs of equal sides.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^5): the initial amount of planks at the company's storehouse, the second line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^5): the lengths of the planks.
The third line contains a single integer q (1 ≤ q ≤ 10^5): the number of events in the company. Each of the next q lines contains a description of the events in a given format: the type of the event (a symbol + or -) is given first, then goes the integer x (1 ≤ x ≤ 10^5).
Output
After every event in the company, print "YES" if two storages of the required shape can be built from the planks of that company's set, and print "NO" otherwise. You can print each letter in any case (upper or lower).
Example
Input
6
1 1 1 2 1 1
6
+ 2
+ 1
- 1
+ 2
- 1
+ 2
Output
NO
YES
NO
NO
NO
YES
Note
After the second event Applejack can build a rectangular storage using planks with lengths 1, 2, 1, 2 and a square storage using planks with lengths 1, 1, 1, 1.
After the sixth event Applejack can build a rectangular storage using planks with lengths 2, 2, 2, 2 and a square storage using planks with lengths 1, 1, 1, 1. | instruction | 0 | 51,525 | 8 | 103,050 |
Tags: constructive algorithms, data structures, greedy, implementation
Correct Solution:
```
import os
import heapq
import sys,threading
import math
import bisect
import operator
from collections import defaultdict
sys.setrecursionlimit(10**5)
from io import BytesIO, IOBase
def gcd(a,b):
if b==0:
return a
else:
return gcd(b,a%b)
def power(x, p,m):
res = 1
while p:
if p & 1:
res = (res * x) % m
x = (x * x) % m
p >>= 1
return res
def inar():
return [int(k) for k in input().split()]
def lcm(num1,num2):
return (num1*num2)//gcd(num1,num2)
def main():
#t=int(input())
t=1
for _ in range(t):
n=int(input())
arr=inar()
q=int(input())
freq=[0]*(10**5+1)
ff=[0]*(10**5+1)
for i in range(n):
freq[arr[i]]+=1
for i in range(10**5+1):
if freq[i]==0:
continue
ff[freq[i]]+=1
#print(ff[0:10])
f=0
s=0
t=0
for i in range(1,10**5+1):
if ff[i]>0:
t=s
s=f
f=i
#print(f,s,t)
for i in range(q):
sign,take=input().split()
take=int(take)
com=0
if sign=="-":
if ff[freq[take]]>0:
ff[freq[take]]-=1
freq[take]-=1
ff[freq[take]]+=1
com=freq[take]
else:
ff[freq[take]] -= 1
freq[take] += 1
ff[freq[take]] += 1
com = freq[take]
#print(ff[0:20])
lis=[0,0,0]
if ff[f]>0:
lis.append(f)
if ff[s]>0:
lis.append(s)
if ff[t]>0:
lis.append(t)
if com!=f and com!=s and com!=t:
lis.append(com)
lis.sort(reverse=True)
f=lis[0]
s=lis[1]
t=lis[2]
#print(f, s, t)
if f >= 8 or (f >= 4 and s >= 4) or (f >= 4 and (f - 4) >= 2 and s >= 2) or (f >= 4 and ff[f] > 1) or (
f >= 4 and s >= 2 and ff[s] > 1) or (f >= 4 and s >= 2 and t >= 2):
print("YES")
else:
print("NO")
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")
if __name__ == "__main__":
main()
#threadin.Thread(target=main).start()
``` | output | 1 | 51,525 | 8 | 103,051 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This year in Equestria was a year of plenty, so Applejack has decided to build some new apple storages. According to the advice of the farm designers, she chose to build two storages with non-zero area: one in the shape of a square and another one in the shape of a rectangle (which possibly can be a square as well).
Applejack will build the storages using planks, she is going to spend exactly one plank on each side of the storage. She can get planks from her friend's company. Initially, the company storehouse has n planks, Applejack knows their lengths. The company keeps working so it receives orders and orders the planks itself. Applejack's friend can provide her with information about each operation. For convenience, he will give her information according to the following format:
* + x: the storehouse received a plank with length x
* - x: one plank with length x was removed from the storehouse (it is guaranteed that the storehouse had some planks with length x).
Applejack is still unsure about when she is going to order the planks so she wants to know if she can order the planks to build rectangular and square storages out of them after every event at the storehouse. Applejack is busy collecting apples and she has completely no time to do the calculations so she asked you for help!
We remind you that all four sides of a square are equal, and a rectangle has two pairs of equal sides.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^5): the initial amount of planks at the company's storehouse, the second line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^5): the lengths of the planks.
The third line contains a single integer q (1 ≤ q ≤ 10^5): the number of events in the company. Each of the next q lines contains a description of the events in a given format: the type of the event (a symbol + or -) is given first, then goes the integer x (1 ≤ x ≤ 10^5).
Output
After every event in the company, print "YES" if two storages of the required shape can be built from the planks of that company's set, and print "NO" otherwise. You can print each letter in any case (upper or lower).
Example
Input
6
1 1 1 2 1 1
6
+ 2
+ 1
- 1
+ 2
- 1
+ 2
Output
NO
YES
NO
NO
NO
YES
Note
After the second event Applejack can build a rectangular storage using planks with lengths 1, 2, 1, 2 and a square storage using planks with lengths 1, 1, 1, 1.
After the sixth event Applejack can build a rectangular storage using planks with lengths 2, 2, 2, 2 and a square storage using planks with lengths 1, 1, 1, 1. | instruction | 0 | 51,526 | 8 | 103,052 |
Tags: constructive algorithms, data structures, greedy, implementation
Correct Solution:
```
'''
Author: nuoyanli
Date: 2020-08-07 21:14:34
LastEditTime: 2020-08-07 23:09:59
Author's blog: https://blog.nuoyanli.com/
Description: Plum blossom from the bitter cold!
'''
import sys
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
ns = lambda: readline().rstrip()
ni = lambda: int(readline().rstrip())
nm = lambda: map(int, readline().split())
nl = lambda: list(map(int, readline().split()))
N = 100010
n = ni()
a = nl()
q = ni()
mmp = [0]*N
for i in a:
mmp[i]+=1
cnt1,cnt2 = 0,0
for i in range(0,N):
if mmp[i]>=4:
cnt1+=1
cnt2+= mmp[i]//2
for _ in range(q):
ch,x = input().split(' ')
x = int(x)
#print(ch,m)
if ch =='+':
cnt2-=mmp[x]//2
mmp[x]+=1
cnt2+=mmp[x]//2
if mmp[x]==4:
cnt1+=1
else:
cnt2-=mmp[x]//2
mmp[x]-=1
cnt2+=mmp[x]//2
if mmp[x]==3:
cnt1-=1
print('YES' if cnt1>0 and cnt2>3 else 'NO')
``` | output | 1 | 51,526 | 8 | 103,053 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This year in Equestria was a year of plenty, so Applejack has decided to build some new apple storages. According to the advice of the farm designers, she chose to build two storages with non-zero area: one in the shape of a square and another one in the shape of a rectangle (which possibly can be a square as well).
Applejack will build the storages using planks, she is going to spend exactly one plank on each side of the storage. She can get planks from her friend's company. Initially, the company storehouse has n planks, Applejack knows their lengths. The company keeps working so it receives orders and orders the planks itself. Applejack's friend can provide her with information about each operation. For convenience, he will give her information according to the following format:
* + x: the storehouse received a plank with length x
* - x: one plank with length x was removed from the storehouse (it is guaranteed that the storehouse had some planks with length x).
Applejack is still unsure about when she is going to order the planks so she wants to know if she can order the planks to build rectangular and square storages out of them after every event at the storehouse. Applejack is busy collecting apples and she has completely no time to do the calculations so she asked you for help!
We remind you that all four sides of a square are equal, and a rectangle has two pairs of equal sides.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^5): the initial amount of planks at the company's storehouse, the second line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^5): the lengths of the planks.
The third line contains a single integer q (1 ≤ q ≤ 10^5): the number of events in the company. Each of the next q lines contains a description of the events in a given format: the type of the event (a symbol + or -) is given first, then goes the integer x (1 ≤ x ≤ 10^5).
Output
After every event in the company, print "YES" if two storages of the required shape can be built from the planks of that company's set, and print "NO" otherwise. You can print each letter in any case (upper or lower).
Example
Input
6
1 1 1 2 1 1
6
+ 2
+ 1
- 1
+ 2
- 1
+ 2
Output
NO
YES
NO
NO
NO
YES
Note
After the second event Applejack can build a rectangular storage using planks with lengths 1, 2, 1, 2 and a square storage using planks with lengths 1, 1, 1, 1.
After the sixth event Applejack can build a rectangular storage using planks with lengths 2, 2, 2, 2 and a square storage using planks with lengths 1, 1, 1, 1.
Submitted Solution:
```
n=int(input())
arr=[int(i) for i in input().split()]
md=dict([])
sq=0
rect=0
for i in arr :
if i in md:
md[i]+=1
if md[i]%4==0 :
sq+=1
rect+=1
elif md[i]%2==0 :
rect+=1
else :
md[i]=1
q=int(input())
i=0
for j in range(q) :
qu=input().split()
if qu[0]=='+' :
i=int(qu[1])
if i in md:
md[i]+=1
if md[i]%4==0 :
sq+=1
rect+=1
elif md[i]%2==0 :
rect+=1
else :
md[i]=1
else :
i=int(qu[1])
if md[i]%4==0 :
sq-=1
rect-=1
elif md[i]%2==0 :
rect-=1
md[i]-=1
if sq>=2 :
print("YES")
elif sq==1 and (rect-2)>=2 :
print("YES")
else :
print("NO")
``` | instruction | 0 | 51,527 | 8 | 103,054 |
Yes | output | 1 | 51,527 | 8 | 103,055 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This year in Equestria was a year of plenty, so Applejack has decided to build some new apple storages. According to the advice of the farm designers, she chose to build two storages with non-zero area: one in the shape of a square and another one in the shape of a rectangle (which possibly can be a square as well).
Applejack will build the storages using planks, she is going to spend exactly one plank on each side of the storage. She can get planks from her friend's company. Initially, the company storehouse has n planks, Applejack knows their lengths. The company keeps working so it receives orders and orders the planks itself. Applejack's friend can provide her with information about each operation. For convenience, he will give her information according to the following format:
* + x: the storehouse received a plank with length x
* - x: one plank with length x was removed from the storehouse (it is guaranteed that the storehouse had some planks with length x).
Applejack is still unsure about when she is going to order the planks so she wants to know if she can order the planks to build rectangular and square storages out of them after every event at the storehouse. Applejack is busy collecting apples and she has completely no time to do the calculations so she asked you for help!
We remind you that all four sides of a square are equal, and a rectangle has two pairs of equal sides.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^5): the initial amount of planks at the company's storehouse, the second line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^5): the lengths of the planks.
The third line contains a single integer q (1 ≤ q ≤ 10^5): the number of events in the company. Each of the next q lines contains a description of the events in a given format: the type of the event (a symbol + or -) is given first, then goes the integer x (1 ≤ x ≤ 10^5).
Output
After every event in the company, print "YES" if two storages of the required shape can be built from the planks of that company's set, and print "NO" otherwise. You can print each letter in any case (upper or lower).
Example
Input
6
1 1 1 2 1 1
6
+ 2
+ 1
- 1
+ 2
- 1
+ 2
Output
NO
YES
NO
NO
NO
YES
Note
After the second event Applejack can build a rectangular storage using planks with lengths 1, 2, 1, 2 and a square storage using planks with lengths 1, 1, 1, 1.
After the sixth event Applejack can build a rectangular storage using planks with lengths 2, 2, 2, 2 and a square storage using planks with lengths 1, 1, 1, 1.
Submitted Solution:
```
from collections import defaultdict
import math
n = int(input())
a = list(map(int, input().rstrip().split(" ")))
q = int(input())
d = defaultdict(lambda : 0)
for ele in a:
d[ele] += 1
count4 = 0
count2 = 0
for key, value in d.items():
count4 += value // 4
value = value % 4
count2 += value // 2
for _ in range(q):
#print(d)
sign, num = input().rstrip().split(" ")
num = int(num)
val = d[num]
#print(count4, count2)
if sign == '+':
if (val + 1) % 4 == 0:
count4 += 1
count2 -= 1
elif (val + 1) % 2 == 0:
count2 += 1
d[num] += 1
else:
if val % 4 == 0:
count4 -= 1
count2 += 1
elif val % 2 == 0:
count2 -= 1
d[num] -= 1
if count4 >= 2 or (count4 == 1 and count2 >= 2):
print('YES')
else:
print('NO')
``` | instruction | 0 | 51,528 | 8 | 103,056 |
Yes | output | 1 | 51,528 | 8 | 103,057 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This year in Equestria was a year of plenty, so Applejack has decided to build some new apple storages. According to the advice of the farm designers, she chose to build two storages with non-zero area: one in the shape of a square and another one in the shape of a rectangle (which possibly can be a square as well).
Applejack will build the storages using planks, she is going to spend exactly one plank on each side of the storage. She can get planks from her friend's company. Initially, the company storehouse has n planks, Applejack knows their lengths. The company keeps working so it receives orders and orders the planks itself. Applejack's friend can provide her with information about each operation. For convenience, he will give her information according to the following format:
* + x: the storehouse received a plank with length x
* - x: one plank with length x was removed from the storehouse (it is guaranteed that the storehouse had some planks with length x).
Applejack is still unsure about when she is going to order the planks so she wants to know if she can order the planks to build rectangular and square storages out of them after every event at the storehouse. Applejack is busy collecting apples and she has completely no time to do the calculations so she asked you for help!
We remind you that all four sides of a square are equal, and a rectangle has two pairs of equal sides.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^5): the initial amount of planks at the company's storehouse, the second line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^5): the lengths of the planks.
The third line contains a single integer q (1 ≤ q ≤ 10^5): the number of events in the company. Each of the next q lines contains a description of the events in a given format: the type of the event (a symbol + or -) is given first, then goes the integer x (1 ≤ x ≤ 10^5).
Output
After every event in the company, print "YES" if two storages of the required shape can be built from the planks of that company's set, and print "NO" otherwise. You can print each letter in any case (upper or lower).
Example
Input
6
1 1 1 2 1 1
6
+ 2
+ 1
- 1
+ 2
- 1
+ 2
Output
NO
YES
NO
NO
NO
YES
Note
After the second event Applejack can build a rectangular storage using planks with lengths 1, 2, 1, 2 and a square storage using planks with lengths 1, 1, 1, 1.
After the sixth event Applejack can build a rectangular storage using planks with lengths 2, 2, 2, 2 and a square storage using planks with lengths 1, 1, 1, 1.
Submitted Solution:
```
n = int(input())
cnt = [0] * (10 ** 5 + 1)
cnt2 = 0
cnt4 = 0
for x in map(int, input().split()):
cnt2 -= cnt[x] // 2
cnt4 -= cnt[x] // 4
cnt[x] += 1
cnt2 += cnt[x] // 2
cnt4 += cnt[x] // 4
for _ in range(int(input())):
sign, x = input().split()
x = int(x)
cnt2 -= cnt[x] // 2
cnt4 -= cnt[x] // 4
if sign == '+':
cnt[x] += 1
else:
cnt[x] -= 1
cnt2 += cnt[x] // 2
cnt4 += cnt[x] // 4
if cnt4 >= 1 and cnt2 >= 4:
print("YES")
else:
print("NO")
``` | instruction | 0 | 51,529 | 8 | 103,058 |
Yes | output | 1 | 51,529 | 8 | 103,059 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This year in Equestria was a year of plenty, so Applejack has decided to build some new apple storages. According to the advice of the farm designers, she chose to build two storages with non-zero area: one in the shape of a square and another one in the shape of a rectangle (which possibly can be a square as well).
Applejack will build the storages using planks, she is going to spend exactly one plank on each side of the storage. She can get planks from her friend's company. Initially, the company storehouse has n planks, Applejack knows their lengths. The company keeps working so it receives orders and orders the planks itself. Applejack's friend can provide her with information about each operation. For convenience, he will give her information according to the following format:
* + x: the storehouse received a plank with length x
* - x: one plank with length x was removed from the storehouse (it is guaranteed that the storehouse had some planks with length x).
Applejack is still unsure about when she is going to order the planks so she wants to know if she can order the planks to build rectangular and square storages out of them after every event at the storehouse. Applejack is busy collecting apples and she has completely no time to do the calculations so she asked you for help!
We remind you that all four sides of a square are equal, and a rectangle has two pairs of equal sides.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^5): the initial amount of planks at the company's storehouse, the second line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^5): the lengths of the planks.
The third line contains a single integer q (1 ≤ q ≤ 10^5): the number of events in the company. Each of the next q lines contains a description of the events in a given format: the type of the event (a symbol + or -) is given first, then goes the integer x (1 ≤ x ≤ 10^5).
Output
After every event in the company, print "YES" if two storages of the required shape can be built from the planks of that company's set, and print "NO" otherwise. You can print each letter in any case (upper or lower).
Example
Input
6
1 1 1 2 1 1
6
+ 2
+ 1
- 1
+ 2
- 1
+ 2
Output
NO
YES
NO
NO
NO
YES
Note
After the second event Applejack can build a rectangular storage using planks with lengths 1, 2, 1, 2 and a square storage using planks with lengths 1, 1, 1, 1.
After the sixth event Applejack can build a rectangular storage using planks with lengths 2, 2, 2, 2 and a square storage using planks with lengths 1, 1, 1, 1.
Submitted Solution:
```
# import sys
# sys.stdin = open('input.txt', 'r')
# sys.stdout = open('output.txt', 'w')
n = int(input())
a = list(map(int, input().split()))
# s = input()
counts = {}
for el in a:
if el in counts:
counts[el] += 1
else:
counts[el] = 1
g2, g4, g6, g8 = 0, 0, 0, 0
for v in counts.values():
if v >= 2:
g2 += 1
if v >= 4:
g4 += 1
if v >= 6:
g6 += 1
if v >= 8:
g8 += 1
q = int(input())
while q:
q -= 1
new, el = input().split()
el = int(el)
if new == '+':
if el in counts:
counts[el] += 1
v = counts[el]
if v == 2:
g2 += 1
if v == 4:
g4 += 1
if v == 6:
g6 += 1
if v == 8:
g8 += 1
else:
counts[el] = 1
else:
counts[el] -= 1
v = counts[el]
if v == 1:
g2 -= 1
if v == 3:
g4 -= 1
if v == 5:
g6 -= 1
if v == 7:
g8 -= 1
# print(g2,g4,g6,g8)
if g8 > 0:
print('YES')
elif g6 > 0:
if g2 > 1:
print('YES')
else:
print('NO')
elif g4 > 1:
print('YES')
elif g4 == 1:
if g2 > 2:
print('YES')
else:
print('NO')
else:
print('NO')
``` | instruction | 0 | 51,530 | 8 | 103,060 |
Yes | output | 1 | 51,530 | 8 | 103,061 |
Evaluate the correctness of the submitted Python 2 solution to the coding contest problem. Provide a "Yes" or "No" response.
This year in Equestria was a year of plenty, so Applejack has decided to build some new apple storages. According to the advice of the farm designers, she chose to build two storages with non-zero area: one in the shape of a square and another one in the shape of a rectangle (which possibly can be a square as well).
Applejack will build the storages using planks, she is going to spend exactly one plank on each side of the storage. She can get planks from her friend's company. Initially, the company storehouse has n planks, Applejack knows their lengths. The company keeps working so it receives orders and orders the planks itself. Applejack's friend can provide her with information about each operation. For convenience, he will give her information according to the following format:
* + x: the storehouse received a plank with length x
* - x: one plank with length x was removed from the storehouse (it is guaranteed that the storehouse had some planks with length x).
Applejack is still unsure about when she is going to order the planks so she wants to know if she can order the planks to build rectangular and square storages out of them after every event at the storehouse. Applejack is busy collecting apples and she has completely no time to do the calculations so she asked you for help!
We remind you that all four sides of a square are equal, and a rectangle has two pairs of equal sides.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^5): the initial amount of planks at the company's storehouse, the second line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^5): the lengths of the planks.
The third line contains a single integer q (1 ≤ q ≤ 10^5): the number of events in the company. Each of the next q lines contains a description of the events in a given format: the type of the event (a symbol + or -) is given first, then goes the integer x (1 ≤ x ≤ 10^5).
Output
After every event in the company, print "YES" if two storages of the required shape can be built from the planks of that company's set, and print "NO" otherwise. You can print each letter in any case (upper or lower).
Example
Input
6
1 1 1 2 1 1
6
+ 2
+ 1
- 1
+ 2
- 1
+ 2
Output
NO
YES
NO
NO
NO
YES
Note
After the second event Applejack can build a rectangular storage using planks with lengths 1, 2, 1, 2 and a square storage using planks with lengths 1, 1, 1, 1.
After the sixth event Applejack can build a rectangular storage using planks with lengths 2, 2, 2, 2 and a square storage using planks with lengths 1, 1, 1, 1.
Submitted Solution:
```
from sys import stdin, stdout
from collections import Counter, defaultdict
from itertools import combinations
pr=stdout.write
raw_input = stdin.readline
def ni():
return int(raw_input())
def li():
return list(map(int,raw_input().split()))
def pn(n):
stdout.write(str(n)+'\n')
def pa(arr):
pr(' '.join(map(str,arr))+'\n')
# fast read function for total integer input
def inp():
# this function returns whole input of
# space/line seperated integers
# Use Ctrl+D to flush stdin.
return (map(int,stdin.read().split()))
range = xrange # not for python 3.0+
import heapq
n=ni()
l=li()
d=Counter()
s1,s2=set(),set()
c1,c2=0,0
for i in l:
d[i]+=1
if d[i]==4:
s1.remove(i)
s2.add(i)
c1-=1
c2+=1
elif d[i]==2:
s1.add(i)
c1+=1
for x in range(ni()):
c,q=raw_input().split()
q=int(q)
if c=='+':
d[q]+=1
if d[q]==4:
s1.remove(q)
s2.add(q)
c1-=1
c2+=1
elif d[q]==2:
c1+=1
s1.add(q)
else:
d[q]-=1
if d[q]==1:
c1-=1
s1.remove(q)
elif d[q]==3:
c2-=1
c1+=1
s2.remove(q)
s1.add(q)
#print s1,s2,c1,c2
if c2>=2:
pr('YES\n')
elif c2:
x=s2.pop()
s2.add(x)
cx=d[x]-4
if (cx/2)+c1>=2:
pr('YES\n')
else:
pr('NO\n')
else:
pr('NO\n')
``` | instruction | 0 | 51,531 | 8 | 103,062 |
Yes | output | 1 | 51,531 | 8 | 103,063 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This year in Equestria was a year of plenty, so Applejack has decided to build some new apple storages. According to the advice of the farm designers, she chose to build two storages with non-zero area: one in the shape of a square and another one in the shape of a rectangle (which possibly can be a square as well).
Applejack will build the storages using planks, she is going to spend exactly one plank on each side of the storage. She can get planks from her friend's company. Initially, the company storehouse has n planks, Applejack knows their lengths. The company keeps working so it receives orders and orders the planks itself. Applejack's friend can provide her with information about each operation. For convenience, he will give her information according to the following format:
* + x: the storehouse received a plank with length x
* - x: one plank with length x was removed from the storehouse (it is guaranteed that the storehouse had some planks with length x).
Applejack is still unsure about when she is going to order the planks so she wants to know if she can order the planks to build rectangular and square storages out of them after every event at the storehouse. Applejack is busy collecting apples and she has completely no time to do the calculations so she asked you for help!
We remind you that all four sides of a square are equal, and a rectangle has two pairs of equal sides.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^5): the initial amount of planks at the company's storehouse, the second line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^5): the lengths of the planks.
The third line contains a single integer q (1 ≤ q ≤ 10^5): the number of events in the company. Each of the next q lines contains a description of the events in a given format: the type of the event (a symbol + or -) is given first, then goes the integer x (1 ≤ x ≤ 10^5).
Output
After every event in the company, print "YES" if two storages of the required shape can be built from the planks of that company's set, and print "NO" otherwise. You can print each letter in any case (upper or lower).
Example
Input
6
1 1 1 2 1 1
6
+ 2
+ 1
- 1
+ 2
- 1
+ 2
Output
NO
YES
NO
NO
NO
YES
Note
After the second event Applejack can build a rectangular storage using planks with lengths 1, 2, 1, 2 and a square storage using planks with lengths 1, 1, 1, 1.
After the sixth event Applejack can build a rectangular storage using planks with lengths 2, 2, 2, 2 and a square storage using planks with lengths 1, 1, 1, 1.
Submitted Solution:
```
n=int(input())
l=list(map(int,input().split()))
four=0
two=0
cnt={}
for x in l:
if x not in cnt:
cnt[x]=1
else:
cnt[x]+=1
for k,v in cnt.items():
four+=(v//4)
two+=((v%4)//2)
q=int(input())
d=cnt.copy()
for i in range(q):
s,p=input().split()
p=int(p)
if(s=='+'):
if p not in d:
cnt[p]=d[p]=1
else:
cnt[p]=d[p]
d[p]+=1
else:
cnt[p]=d[p]
d[p]-=1
print(d[p]," ",cnt[p])
four+=(d[p]//4-cnt[p]//4)
two+=((d[p]%4)//2-(cnt[p]%4)//2)
#print(four,two)
if(four>=2 or (four==1 and two>=2)):
print("YES")
else:
print("NO")
``` | instruction | 0 | 51,532 | 8 | 103,064 |
No | output | 1 | 51,532 | 8 | 103,065 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This year in Equestria was a year of plenty, so Applejack has decided to build some new apple storages. According to the advice of the farm designers, she chose to build two storages with non-zero area: one in the shape of a square and another one in the shape of a rectangle (which possibly can be a square as well).
Applejack will build the storages using planks, she is going to spend exactly one plank on each side of the storage. She can get planks from her friend's company. Initially, the company storehouse has n planks, Applejack knows their lengths. The company keeps working so it receives orders and orders the planks itself. Applejack's friend can provide her with information about each operation. For convenience, he will give her information according to the following format:
* + x: the storehouse received a plank with length x
* - x: one plank with length x was removed from the storehouse (it is guaranteed that the storehouse had some planks with length x).
Applejack is still unsure about when she is going to order the planks so she wants to know if she can order the planks to build rectangular and square storages out of them after every event at the storehouse. Applejack is busy collecting apples and she has completely no time to do the calculations so she asked you for help!
We remind you that all four sides of a square are equal, and a rectangle has two pairs of equal sides.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^5): the initial amount of planks at the company's storehouse, the second line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^5): the lengths of the planks.
The third line contains a single integer q (1 ≤ q ≤ 10^5): the number of events in the company. Each of the next q lines contains a description of the events in a given format: the type of the event (a symbol + or -) is given first, then goes the integer x (1 ≤ x ≤ 10^5).
Output
After every event in the company, print "YES" if two storages of the required shape can be built from the planks of that company's set, and print "NO" otherwise. You can print each letter in any case (upper or lower).
Example
Input
6
1 1 1 2 1 1
6
+ 2
+ 1
- 1
+ 2
- 1
+ 2
Output
NO
YES
NO
NO
NO
YES
Note
After the second event Applejack can build a rectangular storage using planks with lengths 1, 2, 1, 2 and a square storage using planks with lengths 1, 1, 1, 1.
After the sixth event Applejack can build a rectangular storage using planks with lengths 2, 2, 2, 2 and a square storage using planks with lengths 1, 1, 1, 1.
Submitted Solution:
```
def check1(dpp):
if dpp[8]>=1 or dpp[4]>=2:
return "YES"
elif dpp[6]>=1 and dpp[2]>=2:
return "YES"
elif dpp[4]>=1 and dpp[2]>=2:
return "YES"
else:
return "NO"
n=int(input())
dp=[0]*(1000000)
dpp=[0]*(1000000)
arr=list(map(int,input().split()))
for i in arr:
dp[i]+=1
dpp[dp[i]]+=1
for _ in range(int(input())):
a,b=input().split()
if a=='+':
i=int(b)
dp[i]+=1
dpp[dp[i]]+=1
print(check1(dpp))
if a=='-':
i=int(b)
dpp[dp[i]]-=1
dp[i]-=1
print(check1(dpp))
``` | instruction | 0 | 51,533 | 8 | 103,066 |
No | output | 1 | 51,533 | 8 | 103,067 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This year in Equestria was a year of plenty, so Applejack has decided to build some new apple storages. According to the advice of the farm designers, she chose to build two storages with non-zero area: one in the shape of a square and another one in the shape of a rectangle (which possibly can be a square as well).
Applejack will build the storages using planks, she is going to spend exactly one plank on each side of the storage. She can get planks from her friend's company. Initially, the company storehouse has n planks, Applejack knows their lengths. The company keeps working so it receives orders and orders the planks itself. Applejack's friend can provide her with information about each operation. For convenience, he will give her information according to the following format:
* + x: the storehouse received a plank with length x
* - x: one plank with length x was removed from the storehouse (it is guaranteed that the storehouse had some planks with length x).
Applejack is still unsure about when she is going to order the planks so she wants to know if she can order the planks to build rectangular and square storages out of them after every event at the storehouse. Applejack is busy collecting apples and she has completely no time to do the calculations so she asked you for help!
We remind you that all four sides of a square are equal, and a rectangle has two pairs of equal sides.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^5): the initial amount of planks at the company's storehouse, the second line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^5): the lengths of the planks.
The third line contains a single integer q (1 ≤ q ≤ 10^5): the number of events in the company. Each of the next q lines contains a description of the events in a given format: the type of the event (a symbol + or -) is given first, then goes the integer x (1 ≤ x ≤ 10^5).
Output
After every event in the company, print "YES" if two storages of the required shape can be built from the planks of that company's set, and print "NO" otherwise. You can print each letter in any case (upper or lower).
Example
Input
6
1 1 1 2 1 1
6
+ 2
+ 1
- 1
+ 2
- 1
+ 2
Output
NO
YES
NO
NO
NO
YES
Note
After the second event Applejack can build a rectangular storage using planks with lengths 1, 2, 1, 2 and a square storage using planks with lengths 1, 1, 1, 1.
After the sixth event Applejack can build a rectangular storage using planks with lengths 2, 2, 2, 2 and a square storage using planks with lengths 1, 1, 1, 1.
Submitted Solution:
```
plank_lengths = []
num_planks = input()
initial_planks = input()
initial_planks = initial_planks.replace(' ', '')
for i in initial_planks:
plank_lengths.append(int(i))
num_events = input()
num_events = int(num_events)
def square_rectangle(list_input):
list_var = list_input
temp = []
groups = []
temp_groups = []
comparison = list_var[0]
while True:
if len(list_var) == 0:
var = len(temp)
groups.append(var)
break
if comparison == list_var[0]:
temp.append(list_var[0])
list_var.pop(0)
else:
var = len(temp)
groups.append(int(var))
temp = []
comparison = list_var[0]
groups.sort()
for i in groups:
temp_groups.append(i)
temp_groups.pop(-1)
if max(groups) < 4:
result = "NO"
else:
if max(groups) >= 8:
result = "YESa"
else:
if max(temp_groups) >= 4:
result = "YESb"
else:
for i in groups:
if groups.count(i) > 1:
result = "YESc"
else:
if max(groups) >= 6 and min(groups) >= 2:
result = "YESd"
else:
result = "NO"
print(result)
while num_events > 0:
num_events = num_events - 1
user_input = input()
user_input = user_input.replace(' ', '')
if user_input[0] == "+":
plank_lengths.append(int(user_input[1:]))
if user_input[0] == "-":
plank_lengths.remove(int(user_input[1:]))
plank_lengths.sort()
new_list = plank_lengths.copy()
square_rectangle(new_list)
``` | instruction | 0 | 51,534 | 8 | 103,068 |
No | output | 1 | 51,534 | 8 | 103,069 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This year in Equestria was a year of plenty, so Applejack has decided to build some new apple storages. According to the advice of the farm designers, she chose to build two storages with non-zero area: one in the shape of a square and another one in the shape of a rectangle (which possibly can be a square as well).
Applejack will build the storages using planks, she is going to spend exactly one plank on each side of the storage. She can get planks from her friend's company. Initially, the company storehouse has n planks, Applejack knows their lengths. The company keeps working so it receives orders and orders the planks itself. Applejack's friend can provide her with information about each operation. For convenience, he will give her information according to the following format:
* + x: the storehouse received a plank with length x
* - x: one plank with length x was removed from the storehouse (it is guaranteed that the storehouse had some planks with length x).
Applejack is still unsure about when she is going to order the planks so she wants to know if she can order the planks to build rectangular and square storages out of them after every event at the storehouse. Applejack is busy collecting apples and she has completely no time to do the calculations so she asked you for help!
We remind you that all four sides of a square are equal, and a rectangle has two pairs of equal sides.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^5): the initial amount of planks at the company's storehouse, the second line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^5): the lengths of the planks.
The third line contains a single integer q (1 ≤ q ≤ 10^5): the number of events in the company. Each of the next q lines contains a description of the events in a given format: the type of the event (a symbol + or -) is given first, then goes the integer x (1 ≤ x ≤ 10^5).
Output
After every event in the company, print "YES" if two storages of the required shape can be built from the planks of that company's set, and print "NO" otherwise. You can print each letter in any case (upper or lower).
Example
Input
6
1 1 1 2 1 1
6
+ 2
+ 1
- 1
+ 2
- 1
+ 2
Output
NO
YES
NO
NO
NO
YES
Note
After the second event Applejack can build a rectangular storage using planks with lengths 1, 2, 1, 2 and a square storage using planks with lengths 1, 1, 1, 1.
After the sixth event Applejack can build a rectangular storage using planks with lengths 2, 2, 2, 2 and a square storage using planks with lengths 1, 1, 1, 1.
Submitted Solution:
```
import sys
from collections import defaultdict
from functools import lru_cache
from collections import Counter
def mi(s):
return map(int, s.strip().split())
def lmi(s):
return list(mi(s))
def mf(f, s):
return map(f, s)
def lmf(f, s):
return list(mf(f, s))
class BSTNode(object):
def __init__(self, val):
self.val = val
self.disconnect()
def disconnect(self):
self.left = None
self.right = None
self.parent = None
class BST(object):
Node = BSTNode
def __init__(self):
self.root = None
@staticmethod
def minimum(node):
"""Finds and returns the minimum node
in the sub-tree rooted at 'node'.
"""
if node.left is None:
return node
else:
return BST.minimum(node.left)
def __str__(self):
"""
Prints the BST in a visually pleasing format.
Code for printing was acquried from MIT 6.006.
"""
if self.root is None: return '<empty tree>'
def recurse(node):
if node is None: return [], 0, 0
label = str(node.val)
left_lines, left_pos, left_width = recurse(node.left)
right_lines, right_pos, right_width = recurse(node.right)
middle = max(right_pos + left_width - left_pos + 1, len(label), 2)
pos = left_pos + middle // 2
width = left_pos + middle + right_width - right_pos
while len(left_lines) < len(right_lines):
left_lines.append(' ' * left_width)
while len(right_lines) < len(left_lines):
right_lines.append(' ' * right_width)
if (middle - len(label)) % 2 == 1 and node.parent is not None and \
node is node.parent.left and len(label) < middle:
label += '.'
label = label.center(middle, '.')
if label[0] == '.': label = ' ' + label[1:]
if label[-1] == '.': label = label[:-1] + ' '
lines = [' ' * left_pos + label + ' ' * (right_width - right_pos),
' ' * left_pos + '/' + ' ' * (middle-2) +
'\\' + ' ' * (right_width - right_pos)] + \
[left_line + ' ' * (width - left_width - right_width) +
right_line
for left_line, right_line in zip(left_lines, right_lines)]
return lines, pos, width
return '\n'.join(recurse(self.root) [0])
def find(self, val):
"""Searches for val in the BST.
If found, returns the node, else
return None.
"""
def rec_find(node):
if not node:
return None
elif node.val == val:
return node
if node.val <= val:
return rec_find(node.right)
else:
return rec_find(node.left)
return rec_find(self.root)
def __contains__(self, val):
return bool(self.find(val))
def insert(self, val):
"""Inserts the val into the BST.
Returns the newly inserted node.
"""
def rec_insert(node):
if node.val <= val:
if not node.right:
node.right = new_node
new_node.parent = node
else:
rec_insert(node.right)
else:
if not node.left:
node.left = new_node
new_node.parent = node
else:
rec_insert(node.left)
new_node = self.Node(val)
if not self.root:
self.root = new_node
else:
rec_insert(self.root)
return new_node
def delete(self, val):
"""Deletes the node corresposnding to val
from the BST.
Returns a (deleted node, parent node) tuple."""
def fix_attrs(node, new_node):
if node.parent:
if node is node.parent.left:
node.parent.left = new_node
else:
node.parent.right = new_node
else:
self.root = new_node
if new_node:
new_node.parent = node.parent
def delete_node(node):
if node.left and node.right:
right_minimum = self.minimum(node.right)
right_minimum.val, node.val = node.val, right_minimum.val
return delete_node(right_minimum)
elif node.left:
new_node = node.left
else:
new_node = node.right
fix_attrs(node, new_node)
parent = node.parent
node.disconnect()
return node, parent
to_delete = self.find(val)
if not to_delete:
return (None, None)
else:
return delete_node(to_delete)
def height(node):
if not node:
return -1
else:
return node.height
def update_height(node):
node.height = 1 + max(height(node.left), height(node.right))
def balanced(node):
"""Returns True if the AVL property is maintained
for the given node.
"""
return abs(height(node.left) - height(node.right)) <= 1
class AVLNode(BSTNode):
"""An AVLNode is a BSTNode with a height attribute."""
def __init__(self, val):
super(AVLNode, self).__init__(val)
self.height = 0
class AVL(BST):
"""A BST which maintains O(log(n)) height using by maintaining
the AVL property.
"""
Node = AVLNode
def rotate_left(self, node):
right_node = node.right
# Left rotate is not possible
# when node.right is None.
if not right_node:
raise ValueError("Left rotate not possible.")
if node.parent:
if node is node.parent.left:
node.parent.left = right_node
else:
node.parent.right = right_node
else:
self.root = right_node
node.parent, right_node.parent = right_node, node.parent
right_left_node = right_node.left
if right_left_node:
right_left_node.parent = node
right_node.left = node
node.right = right_left_node
update_height(node)
update_height(right_node)
return node, right_node
def rotate_right(self, node):
left_node = node.left
# Right rotate is not possible
# when node.left is None.
if not left_node:
raise ValueError("Right rotate not possible.")
if node.parent:
if node is node.parent.left:
node.parent.left = left_node
else:
node.parent.right = left_node
else:
self.root = left_node
node.parent, left_node.parent = left_node, node.parent
left_right_node = left_node.right
if left_right_node:
left_right_node.parent = node
left_node.right = node
node.left = left_right_node
update_height(node)
update_height(left_node)
return node, left_node
def fix_one_imbalance(self, node):
"""Fixes an AVL imbalance for the given node.
We assume that this function is only called when an imbalance exists."""
left_heavy = height(node.left) > height(node.right)
if left_heavy:
left_left_heavy = height(node.left.left) >= height(node.left.right)
if left_left_heavy:
self.rotate_right(node)
else:
self.rotate_left(node.left)
self.rotate_right(node)
else:
right_right_heavy = height(node.right.right) >= height(node.right.left)
if right_right_heavy:
self.rotate_left(node)
else:
self.rotate_right(node.right)
self.rotate_left(node)
def fix_tree_imbalance(self, node):
if node is None:
return
parent = node.parent
update_height(node)
if not balanced(node):
self.fix_one_imbalance(node)
self.fix_tree_imbalance(parent)
def insert(self, val):
"""Overrides the insert method of BST.
Updates heights and rotates.
"""
new_node = super(AVL, self).insert(val)
self.fix_tree_imbalance(new_node)
return new_node
def delete(self, val):
"""Overrides the delete method of BST.
Updates heights and rotates.
"""
deleted, parent = super(AVL, self).delete(val)
if deleted and parent:
self.fix_tree_imbalance(parent)
return deleted, parent
def size(node):
if not node:
return 0
else:
return node.size
def update_size(node):
node.size = 1 + size(node.left) + size(node.right)
def largest(node, parent=None):
'''
Returns the largest node in the tree
given the node.
'''
if not node:
return None
while node.right:
parent = node
node = node.right
return node, parent
def get_largest(tree):
'''
Gets the 3 highest frequency nodes in the tree.
'''
if tree.root is None:
return []
node, parent = largest(tree.root)
ans = [node.val]
if node.left:
second_largest, second_parent = largest(node.left, node)
ans.append(second_largest.val)
if second_largest.left:
third_largest, third_parent = largest(second_largest.left, second_largest)
ans.append(third_largest.val)
elif second_parent and second_parent.val not in ans:
ans.append(second_parent.val)
else:
if parent:
ans.append(parent.val)
# third largest?
if parent.left:
third_largest, third_parent = largest(parent.left, parent)
ans.append(third_largest.val)
elif parent.parent and parent.parent.val not in ans:
ans.append(parent.parent.val)
return ans
def main(curr, ops):
counts = Counter(curr)
tree = AVL()
# Node name to its node in the actual tree.
node_map = {}
for k in counts:
new_node = tree.insert((counts[k], k))
node_map[k] = new_node
for op, n in ops:
if op == '+':
if n in node_map:
old_node = node_map[n]
prev_count, _ = old_node.val
tree.delete((prev_count, n))
new_node = tree.insert((prev_count + 1, n))
node_map[n] = new_node
else:
new_node = tree.insert((1, n))
node_map[n] = new_node
else:
prev_count, n = node_map[n].val
tree.delete((prev_count, n))
if prev_count > 1:
new_node = tree.insert((prev_count - 1, n))
node_map[n] = new_node
largest = get_largest(tree)
if largest[0][0] >= 8:
print("YES")
elif len(largest) >= 2 and largest[0][0] >= 6 and largest[1][0] >= 2:
print("YES")
elif len(largest) >= 2 and largest[0][0] >= 4 and largest[1][0] >= 4:
print("YES")
elif len(largest) >= 3 and largest[0][0] >= 4 and largest[1][0] >= 2 and largest[2][0] >= 2:
print("YES")
else:
print("NO")
if __name__ == "__main__":
curr = []
ops = []
for e, line in enumerate(sys.stdin.readlines()):
if e == 0:
continue
elif e == 1:
curr = lmi(line)
elif e == 2:
continue
else:
op, n = line.strip().split()
ops.append((op, int(n)))
main(curr, ops)
``` | instruction | 0 | 51,535 | 8 | 103,070 |
No | output | 1 | 51,535 | 8 | 103,071 |
Provide a correct Python 3 solution for this coding contest problem.
There are N mountains in a circle, called Mountain 1, Mountain 2, ..., Mountain N in clockwise order. N is an odd number.
Between these mountains, there are N dams, called Dam 1, Dam 2, ..., Dam N. Dam i (1 \leq i \leq N) is located between Mountain i and i+1 (Mountain N+1 is Mountain 1).
When Mountain i (1 \leq i \leq N) receives 2x liters of rain, Dam i-1 and Dam i each accumulates x liters of water (Dam 0 is Dam N).
One day, each of the mountains received a non-negative even number of liters of rain.
As a result, Dam i (1 \leq i \leq N) accumulated a total of A_i liters of water.
Find the amount of rain each of the mountains received. We can prove that the solution is unique under the constraints of this problem.
Constraints
* All values in input are integers.
* 3 \leq N \leq 10^5-1
* N is an odd number.
* 0 \leq A_i \leq 10^9
* The situation represented by input can occur when each of the mountains receives a non-negative even number of liters of rain.
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 ... A_N
Output
Print N integers representing the number of liters of rain Mountain 1, Mountain 2, ..., Mountain N received, in this order.
Examples
Input
3
2 2 4
Output
4 0 4
Input
5
3 8 7 5 5
Output
2 4 12 2 8
Input
3
1000000000 1000000000 0
Output
0 2000000000 0 | instruction | 0 | 51,964 | 8 | 103,928 |
"Correct Solution:
```
N=int(input())
A=[i for i in map(int,input().split())]
X=[0]*N
X[0]=sum(A[0::2])-sum(A[1::2])
for i in range(1, N):
X[i]=2*A[i-1]-X[i-1]
print(' '.join(map(str,X)))
``` | output | 1 | 51,964 | 8 | 103,929 |
Provide a correct Python 3 solution for this coding contest problem.
There are N mountains in a circle, called Mountain 1, Mountain 2, ..., Mountain N in clockwise order. N is an odd number.
Between these mountains, there are N dams, called Dam 1, Dam 2, ..., Dam N. Dam i (1 \leq i \leq N) is located between Mountain i and i+1 (Mountain N+1 is Mountain 1).
When Mountain i (1 \leq i \leq N) receives 2x liters of rain, Dam i-1 and Dam i each accumulates x liters of water (Dam 0 is Dam N).
One day, each of the mountains received a non-negative even number of liters of rain.
As a result, Dam i (1 \leq i \leq N) accumulated a total of A_i liters of water.
Find the amount of rain each of the mountains received. We can prove that the solution is unique under the constraints of this problem.
Constraints
* All values in input are integers.
* 3 \leq N \leq 10^5-1
* N is an odd number.
* 0 \leq A_i \leq 10^9
* The situation represented by input can occur when each of the mountains receives a non-negative even number of liters of rain.
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 ... A_N
Output
Print N integers representing the number of liters of rain Mountain 1, Mountain 2, ..., Mountain N received, in this order.
Examples
Input
3
2 2 4
Output
4 0 4
Input
5
3 8 7 5 5
Output
2 4 12 2 8
Input
3
1000000000 1000000000 0
Output
0 2000000000 0 | instruction | 0 | 51,965 | 8 | 103,930 |
"Correct Solution:
```
N = int(input())
a = [int(i) for i in input().split()]
b=[0]*(N+1)
b[0] = sum(a)-2*sum(a[1::2])
for i in range(1,N+1):
b[i] = 2*a[i-1] - b[i-1]
print(*b[:N])
``` | output | 1 | 51,965 | 8 | 103,931 |
Provide a correct Python 3 solution for this coding contest problem.
There are N mountains in a circle, called Mountain 1, Mountain 2, ..., Mountain N in clockwise order. N is an odd number.
Between these mountains, there are N dams, called Dam 1, Dam 2, ..., Dam N. Dam i (1 \leq i \leq N) is located between Mountain i and i+1 (Mountain N+1 is Mountain 1).
When Mountain i (1 \leq i \leq N) receives 2x liters of rain, Dam i-1 and Dam i each accumulates x liters of water (Dam 0 is Dam N).
One day, each of the mountains received a non-negative even number of liters of rain.
As a result, Dam i (1 \leq i \leq N) accumulated a total of A_i liters of water.
Find the amount of rain each of the mountains received. We can prove that the solution is unique under the constraints of this problem.
Constraints
* All values in input are integers.
* 3 \leq N \leq 10^5-1
* N is an odd number.
* 0 \leq A_i \leq 10^9
* The situation represented by input can occur when each of the mountains receives a non-negative even number of liters of rain.
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 ... A_N
Output
Print N integers representing the number of liters of rain Mountain 1, Mountain 2, ..., Mountain N received, in this order.
Examples
Input
3
2 2 4
Output
4 0 4
Input
5
3 8 7 5 5
Output
2 4 12 2 8
Input
3
1000000000 1000000000 0
Output
0 2000000000 0 | instruction | 0 | 51,966 | 8 | 103,932 |
"Correct Solution:
```
N=int(input())
A=list(map(int,input().split()))
s=sum(A)
ans=[s-2*sum(A[1::2])]
for i in range(0,N-1):
ans.append(A[i]*2-ans[-1])
print(*ans)
``` | output | 1 | 51,966 | 8 | 103,933 |
Provide a correct Python 3 solution for this coding contest problem.
There are N mountains in a circle, called Mountain 1, Mountain 2, ..., Mountain N in clockwise order. N is an odd number.
Between these mountains, there are N dams, called Dam 1, Dam 2, ..., Dam N. Dam i (1 \leq i \leq N) is located between Mountain i and i+1 (Mountain N+1 is Mountain 1).
When Mountain i (1 \leq i \leq N) receives 2x liters of rain, Dam i-1 and Dam i each accumulates x liters of water (Dam 0 is Dam N).
One day, each of the mountains received a non-negative even number of liters of rain.
As a result, Dam i (1 \leq i \leq N) accumulated a total of A_i liters of water.
Find the amount of rain each of the mountains received. We can prove that the solution is unique under the constraints of this problem.
Constraints
* All values in input are integers.
* 3 \leq N \leq 10^5-1
* N is an odd number.
* 0 \leq A_i \leq 10^9
* The situation represented by input can occur when each of the mountains receives a non-negative even number of liters of rain.
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 ... A_N
Output
Print N integers representing the number of liters of rain Mountain 1, Mountain 2, ..., Mountain N received, in this order.
Examples
Input
3
2 2 4
Output
4 0 4
Input
5
3 8 7 5 5
Output
2 4 12 2 8
Input
3
1000000000 1000000000 0
Output
0 2000000000 0 | instruction | 0 | 51,967 | 8 | 103,934 |
"Correct Solution:
```
N = int(input())
l_a = list(map(int,input().split()))
b_x = sum(l_a) - sum(l_a[1::2])*2
l_x =[b_x]
for s in range(N-1):
x = l_a[s]*2 - b_x
l_x.append(x)
b_x = x
print(*l_x)
``` | output | 1 | 51,967 | 8 | 103,935 |
Provide a correct Python 3 solution for this coding contest problem.
There are N mountains in a circle, called Mountain 1, Mountain 2, ..., Mountain N in clockwise order. N is an odd number.
Between these mountains, there are N dams, called Dam 1, Dam 2, ..., Dam N. Dam i (1 \leq i \leq N) is located between Mountain i and i+1 (Mountain N+1 is Mountain 1).
When Mountain i (1 \leq i \leq N) receives 2x liters of rain, Dam i-1 and Dam i each accumulates x liters of water (Dam 0 is Dam N).
One day, each of the mountains received a non-negative even number of liters of rain.
As a result, Dam i (1 \leq i \leq N) accumulated a total of A_i liters of water.
Find the amount of rain each of the mountains received. We can prove that the solution is unique under the constraints of this problem.
Constraints
* All values in input are integers.
* 3 \leq N \leq 10^5-1
* N is an odd number.
* 0 \leq A_i \leq 10^9
* The situation represented by input can occur when each of the mountains receives a non-negative even number of liters of rain.
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 ... A_N
Output
Print N integers representing the number of liters of rain Mountain 1, Mountain 2, ..., Mountain N received, in this order.
Examples
Input
3
2 2 4
Output
4 0 4
Input
5
3 8 7 5 5
Output
2 4 12 2 8
Input
3
1000000000 1000000000 0
Output
0 2000000000 0 | instruction | 0 | 51,968 | 8 | 103,936 |
"Correct Solution:
```
n=int(input())
a=list(map(int,input().split()))
a0=sum(a)//2-sum(a[1::2])
ans=[a0*2]
for i in range(n-2):
ans.append(a[i]*2-ans[-1])
ans.append((a[-1]-a0)*2)
print(*ans)
``` | output | 1 | 51,968 | 8 | 103,937 |
Provide a correct Python 3 solution for this coding contest problem.
There are N mountains in a circle, called Mountain 1, Mountain 2, ..., Mountain N in clockwise order. N is an odd number.
Between these mountains, there are N dams, called Dam 1, Dam 2, ..., Dam N. Dam i (1 \leq i \leq N) is located between Mountain i and i+1 (Mountain N+1 is Mountain 1).
When Mountain i (1 \leq i \leq N) receives 2x liters of rain, Dam i-1 and Dam i each accumulates x liters of water (Dam 0 is Dam N).
One day, each of the mountains received a non-negative even number of liters of rain.
As a result, Dam i (1 \leq i \leq N) accumulated a total of A_i liters of water.
Find the amount of rain each of the mountains received. We can prove that the solution is unique under the constraints of this problem.
Constraints
* All values in input are integers.
* 3 \leq N \leq 10^5-1
* N is an odd number.
* 0 \leq A_i \leq 10^9
* The situation represented by input can occur when each of the mountains receives a non-negative even number of liters of rain.
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 ... A_N
Output
Print N integers representing the number of liters of rain Mountain 1, Mountain 2, ..., Mountain N received, in this order.
Examples
Input
3
2 2 4
Output
4 0 4
Input
5
3 8 7 5 5
Output
2 4 12 2 8
Input
3
1000000000 1000000000 0
Output
0 2000000000 0 | instruction | 0 | 51,969 | 8 | 103,938 |
"Correct Solution:
```
n=int(input())
A=list(map(int,input().split()))
X=[0]*n
S=sum(A)
A2=0
for i in range(1,n-1,2):
A2+=A[i]
X[0]=S-2*A2
for i in range(1,n):
X[i]=2*A[i-1]-X[i-1]
print(*X)
``` | output | 1 | 51,969 | 8 | 103,939 |
Provide a correct Python 3 solution for this coding contest problem.
There are N mountains in a circle, called Mountain 1, Mountain 2, ..., Mountain N in clockwise order. N is an odd number.
Between these mountains, there are N dams, called Dam 1, Dam 2, ..., Dam N. Dam i (1 \leq i \leq N) is located between Mountain i and i+1 (Mountain N+1 is Mountain 1).
When Mountain i (1 \leq i \leq N) receives 2x liters of rain, Dam i-1 and Dam i each accumulates x liters of water (Dam 0 is Dam N).
One day, each of the mountains received a non-negative even number of liters of rain.
As a result, Dam i (1 \leq i \leq N) accumulated a total of A_i liters of water.
Find the amount of rain each of the mountains received. We can prove that the solution is unique under the constraints of this problem.
Constraints
* All values in input are integers.
* 3 \leq N \leq 10^5-1
* N is an odd number.
* 0 \leq A_i \leq 10^9
* The situation represented by input can occur when each of the mountains receives a non-negative even number of liters of rain.
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 ... A_N
Output
Print N integers representing the number of liters of rain Mountain 1, Mountain 2, ..., Mountain N received, in this order.
Examples
Input
3
2 2 4
Output
4 0 4
Input
5
3 8 7 5 5
Output
2 4 12 2 8
Input
3
1000000000 1000000000 0
Output
0 2000000000 0 | instruction | 0 | 51,970 | 8 | 103,940 |
"Correct Solution:
```
n = int(input())
a = list(map(int, input().split()))
ans = [0] * n
ans[0] = sum(a) - sum(a[1::2])*2
for i in range(1, n):
ans[i] = (a[i-1] - ans[i-1]//2) * 2
print(*ans)
``` | output | 1 | 51,970 | 8 | 103,941 |
Provide a correct Python 3 solution for this coding contest problem.
There are N mountains in a circle, called Mountain 1, Mountain 2, ..., Mountain N in clockwise order. N is an odd number.
Between these mountains, there are N dams, called Dam 1, Dam 2, ..., Dam N. Dam i (1 \leq i \leq N) is located between Mountain i and i+1 (Mountain N+1 is Mountain 1).
When Mountain i (1 \leq i \leq N) receives 2x liters of rain, Dam i-1 and Dam i each accumulates x liters of water (Dam 0 is Dam N).
One day, each of the mountains received a non-negative even number of liters of rain.
As a result, Dam i (1 \leq i \leq N) accumulated a total of A_i liters of water.
Find the amount of rain each of the mountains received. We can prove that the solution is unique under the constraints of this problem.
Constraints
* All values in input are integers.
* 3 \leq N \leq 10^5-1
* N is an odd number.
* 0 \leq A_i \leq 10^9
* The situation represented by input can occur when each of the mountains receives a non-negative even number of liters of rain.
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 ... A_N
Output
Print N integers representing the number of liters of rain Mountain 1, Mountain 2, ..., Mountain N received, in this order.
Examples
Input
3
2 2 4
Output
4 0 4
Input
5
3 8 7 5 5
Output
2 4 12 2 8
Input
3
1000000000 1000000000 0
Output
0 2000000000 0 | instruction | 0 | 51,971 | 8 | 103,942 |
"Correct Solution:
```
n = int(input())
a = list(map(int, input().split()))
ans = []
x0 = sum(a) - 2 * sum(a[1::2])
ans.append(x0)
for i in range(1,n):
ans.append(2*a[i-1] - ans[-1])
print(*ans)
``` | output | 1 | 51,971 | 8 | 103,943 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N mountains in a circle, called Mountain 1, Mountain 2, ..., Mountain N in clockwise order. N is an odd number.
Between these mountains, there are N dams, called Dam 1, Dam 2, ..., Dam N. Dam i (1 \leq i \leq N) is located between Mountain i and i+1 (Mountain N+1 is Mountain 1).
When Mountain i (1 \leq i \leq N) receives 2x liters of rain, Dam i-1 and Dam i each accumulates x liters of water (Dam 0 is Dam N).
One day, each of the mountains received a non-negative even number of liters of rain.
As a result, Dam i (1 \leq i \leq N) accumulated a total of A_i liters of water.
Find the amount of rain each of the mountains received. We can prove that the solution is unique under the constraints of this problem.
Constraints
* All values in input are integers.
* 3 \leq N \leq 10^5-1
* N is an odd number.
* 0 \leq A_i \leq 10^9
* The situation represented by input can occur when each of the mountains receives a non-negative even number of liters of rain.
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 ... A_N
Output
Print N integers representing the number of liters of rain Mountain 1, Mountain 2, ..., Mountain N received, in this order.
Examples
Input
3
2 2 4
Output
4 0 4
Input
5
3 8 7 5 5
Output
2 4 12 2 8
Input
3
1000000000 1000000000 0
Output
0 2000000000 0
Submitted Solution:
```
n = int(input())
A = list(map(int,input().split()))
x = [0]*n
S = sum(A)
A2 = A[1::2]
x[0] = S - 2*sum(A2)
for i in range(n-1):
x[i+1] = 2*A[i]-x[i]
print(*x)
``` | instruction | 0 | 51,972 | 8 | 103,944 |
Yes | output | 1 | 51,972 | 8 | 103,945 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N mountains in a circle, called Mountain 1, Mountain 2, ..., Mountain N in clockwise order. N is an odd number.
Between these mountains, there are N dams, called Dam 1, Dam 2, ..., Dam N. Dam i (1 \leq i \leq N) is located between Mountain i and i+1 (Mountain N+1 is Mountain 1).
When Mountain i (1 \leq i \leq N) receives 2x liters of rain, Dam i-1 and Dam i each accumulates x liters of water (Dam 0 is Dam N).
One day, each of the mountains received a non-negative even number of liters of rain.
As a result, Dam i (1 \leq i \leq N) accumulated a total of A_i liters of water.
Find the amount of rain each of the mountains received. We can prove that the solution is unique under the constraints of this problem.
Constraints
* All values in input are integers.
* 3 \leq N \leq 10^5-1
* N is an odd number.
* 0 \leq A_i \leq 10^9
* The situation represented by input can occur when each of the mountains receives a non-negative even number of liters of rain.
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 ... A_N
Output
Print N integers representing the number of liters of rain Mountain 1, Mountain 2, ..., Mountain N received, in this order.
Examples
Input
3
2 2 4
Output
4 0 4
Input
5
3 8 7 5 5
Output
2 4 12 2 8
Input
3
1000000000 1000000000 0
Output
0 2000000000 0
Submitted Solution:
```
n = int(input())
a = list(map(int, input().split()))
x = sum(a) - sum(a[1::2])*2
for i in range(n):
print(x, end=' ')
x = a[i]*2 - x
``` | instruction | 0 | 51,973 | 8 | 103,946 |
Yes | output | 1 | 51,973 | 8 | 103,947 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N mountains in a circle, called Mountain 1, Mountain 2, ..., Mountain N in clockwise order. N is an odd number.
Between these mountains, there are N dams, called Dam 1, Dam 2, ..., Dam N. Dam i (1 \leq i \leq N) is located between Mountain i and i+1 (Mountain N+1 is Mountain 1).
When Mountain i (1 \leq i \leq N) receives 2x liters of rain, Dam i-1 and Dam i each accumulates x liters of water (Dam 0 is Dam N).
One day, each of the mountains received a non-negative even number of liters of rain.
As a result, Dam i (1 \leq i \leq N) accumulated a total of A_i liters of water.
Find the amount of rain each of the mountains received. We can prove that the solution is unique under the constraints of this problem.
Constraints
* All values in input are integers.
* 3 \leq N \leq 10^5-1
* N is an odd number.
* 0 \leq A_i \leq 10^9
* The situation represented by input can occur when each of the mountains receives a non-negative even number of liters of rain.
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 ... A_N
Output
Print N integers representing the number of liters of rain Mountain 1, Mountain 2, ..., Mountain N received, in this order.
Examples
Input
3
2 2 4
Output
4 0 4
Input
5
3 8 7 5 5
Output
2 4 12 2 8
Input
3
1000000000 1000000000 0
Output
0 2000000000 0
Submitted Solution:
```
N = int(input())
A = list(map(int, input().split()))
S = sum(A)
Y = [0]*N
Y[0] = S - 2*sum(A[1::2])
for i in range(1,N):
Y[i] = 2*A[i-1] - Y[i-1]
print(*Y)
``` | instruction | 0 | 51,975 | 8 | 103,950 |
Yes | output | 1 | 51,975 | 8 | 103,951 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N mountains in a circle, called Mountain 1, Mountain 2, ..., Mountain N in clockwise order. N is an odd number.
Between these mountains, there are N dams, called Dam 1, Dam 2, ..., Dam N. Dam i (1 \leq i \leq N) is located between Mountain i and i+1 (Mountain N+1 is Mountain 1).
When Mountain i (1 \leq i \leq N) receives 2x liters of rain, Dam i-1 and Dam i each accumulates x liters of water (Dam 0 is Dam N).
One day, each of the mountains received a non-negative even number of liters of rain.
As a result, Dam i (1 \leq i \leq N) accumulated a total of A_i liters of water.
Find the amount of rain each of the mountains received. We can prove that the solution is unique under the constraints of this problem.
Constraints
* All values in input are integers.
* 3 \leq N \leq 10^5-1
* N is an odd number.
* 0 \leq A_i \leq 10^9
* The situation represented by input can occur when each of the mountains receives a non-negative even number of liters of rain.
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 ... A_N
Output
Print N integers representing the number of liters of rain Mountain 1, Mountain 2, ..., Mountain N received, in this order.
Examples
Input
3
2 2 4
Output
4 0 4
Input
5
3 8 7 5 5
Output
2 4 12 2 8
Input
3
1000000000 1000000000 0
Output
0 2000000000 0
Submitted Solution:
```
n = int(input())
a = list(map(int,input().split()))
ans = sum(a)
a = a+a
m = (n-1)/2
ls = [ans for _ in range(n)]
for i in range(n):
for j in range(int(m)):
ls[i] = str(ls[i]-2*(a[i+1+2*j]))
print(" ".join(ls))
``` | instruction | 0 | 51,976 | 8 | 103,952 |
No | output | 1 | 51,976 | 8 | 103,953 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N mountains in a circle, called Mountain 1, Mountain 2, ..., Mountain N in clockwise order. N is an odd number.
Between these mountains, there are N dams, called Dam 1, Dam 2, ..., Dam N. Dam i (1 \leq i \leq N) is located between Mountain i and i+1 (Mountain N+1 is Mountain 1).
When Mountain i (1 \leq i \leq N) receives 2x liters of rain, Dam i-1 and Dam i each accumulates x liters of water (Dam 0 is Dam N).
One day, each of the mountains received a non-negative even number of liters of rain.
As a result, Dam i (1 \leq i \leq N) accumulated a total of A_i liters of water.
Find the amount of rain each of the mountains received. We can prove that the solution is unique under the constraints of this problem.
Constraints
* All values in input are integers.
* 3 \leq N \leq 10^5-1
* N is an odd number.
* 0 \leq A_i \leq 10^9
* The situation represented by input can occur when each of the mountains receives a non-negative even number of liters of rain.
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 ... A_N
Output
Print N integers representing the number of liters of rain Mountain 1, Mountain 2, ..., Mountain N received, in this order.
Examples
Input
3
2 2 4
Output
4 0 4
Input
5
3 8 7 5 5
Output
2 4 12 2 8
Input
3
1000000000 1000000000 0
Output
0 2000000000 0
Submitted Solution:
```
N = int(input())
A_list = list(map(int, input().split()))
R1 = sum(A_list) - 2 * sum(A_list[i] for i in range(1,N,2))
Ri_list = [0] * N
Ri_list[0] = R1
for i in range(1,N):
print(A_list[i-1])
Ri_list[i] = A_list[i-1] * 2 - Ri_list[i-1]
for item in Ri_list:
print(item, end=' ')
``` | instruction | 0 | 51,977 | 8 | 103,954 |
No | output | 1 | 51,977 | 8 | 103,955 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N mountains in a circle, called Mountain 1, Mountain 2, ..., Mountain N in clockwise order. N is an odd number.
Between these mountains, there are N dams, called Dam 1, Dam 2, ..., Dam N. Dam i (1 \leq i \leq N) is located between Mountain i and i+1 (Mountain N+1 is Mountain 1).
When Mountain i (1 \leq i \leq N) receives 2x liters of rain, Dam i-1 and Dam i each accumulates x liters of water (Dam 0 is Dam N).
One day, each of the mountains received a non-negative even number of liters of rain.
As a result, Dam i (1 \leq i \leq N) accumulated a total of A_i liters of water.
Find the amount of rain each of the mountains received. We can prove that the solution is unique under the constraints of this problem.
Constraints
* All values in input are integers.
* 3 \leq N \leq 10^5-1
* N is an odd number.
* 0 \leq A_i \leq 10^9
* The situation represented by input can occur when each of the mountains receives a non-negative even number of liters of rain.
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 ... A_N
Output
Print N integers representing the number of liters of rain Mountain 1, Mountain 2, ..., Mountain N received, in this order.
Examples
Input
3
2 2 4
Output
4 0 4
Input
5
3 8 7 5 5
Output
2 4 12 2 8
Input
3
1000000000 1000000000 0
Output
0 2000000000 0
Submitted Solution:
```
n = int(input())
a = list(map(int, input().split()))
sum_a = sum(a)
b = [0]*n
ok = -1
ng = min(a[-1], a[0]) + 1
if ng - ok == 1:
b[0] = 0
for i in range(1, n):
b[i] = (a[i - 1] - b[i - 1] // 2) * 2
else:
while ng - ok > 1:
mid = (ok + ng)//2
b[0] = mid*2
for i in range(1, n):
b[i] = (a[i-1] - b[i-1]//2)*2
if sum(b) <= sum_a:
ok = mid
elif sum(b) > sum_a:
ng = mid
print(*b)
``` | instruction | 0 | 51,978 | 8 | 103,956 |
No | output | 1 | 51,978 | 8 | 103,957 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N mountains in a circle, called Mountain 1, Mountain 2, ..., Mountain N in clockwise order. N is an odd number.
Between these mountains, there are N dams, called Dam 1, Dam 2, ..., Dam N. Dam i (1 \leq i \leq N) is located between Mountain i and i+1 (Mountain N+1 is Mountain 1).
When Mountain i (1 \leq i \leq N) receives 2x liters of rain, Dam i-1 and Dam i each accumulates x liters of water (Dam 0 is Dam N).
One day, each of the mountains received a non-negative even number of liters of rain.
As a result, Dam i (1 \leq i \leq N) accumulated a total of A_i liters of water.
Find the amount of rain each of the mountains received. We can prove that the solution is unique under the constraints of this problem.
Constraints
* All values in input are integers.
* 3 \leq N \leq 10^5-1
* N is an odd number.
* 0 \leq A_i \leq 10^9
* The situation represented by input can occur when each of the mountains receives a non-negative even number of liters of rain.
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 ... A_N
Output
Print N integers representing the number of liters of rain Mountain 1, Mountain 2, ..., Mountain N received, in this order.
Examples
Input
3
2 2 4
Output
4 0 4
Input
5
3 8 7 5 5
Output
2 4 12 2 8
Input
3
1000000000 1000000000 0
Output
0 2000000000 0
Submitted Solution:
```
n = int(input())
a = list(map(int, input().split()))
b = []
b.append(sum(a) - 2*sum(a[1:n-1]))
i = 0
while i < n-1:
b.append(2*a[i]-b[i])
i += 1
print(*b)
``` | instruction | 0 | 51,979 | 8 | 103,958 |
No | output | 1 | 51,979 | 8 | 103,959 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ujan decided to make a new wooden roof for the house. He has n rectangular planks numbered from 1 to n. The i-th plank has size a_i × 1 (that is, the width is 1 and the height is a_i).
Now, Ujan wants to make a square roof. He will first choose some of the planks and place them side by side in some order. Then he will glue together all of these planks by their vertical sides. Finally, he will cut out a square from the resulting shape in such a way that the sides of the square are horizontal and vertical.
For example, if Ujan had planks with lengths 4, 3, 1, 4 and 5, he could choose planks with lengths 4, 3 and 5. Then he can cut out a 3 × 3 square, which is the maximum possible. Note that this is not the only way he can obtain a 3 × 3 square.
<image>
What is the maximum side length of the square Ujan can get?
Input
The first line of input contains a single integer k (1 ≤ k ≤ 10), the number of test cases in the input.
For each test case, the first line contains a single integer n (1 ≤ n ≤ 1 000), the number of planks Ujan has in store. The next line contains n integers a_1, …, a_n (1 ≤ a_i ≤ n), the lengths of the planks.
Output
For each of the test cases, output a single integer, the maximum possible side length of the square.
Example
Input
4
5
4 3 1 4 5
4
4 4 4 4
3
1 1 1
5
5 5 1 1 5
Output
3
4
1
3
Note
The first sample corresponds to the example in the statement.
In the second sample, gluing all 4 planks will result in a 4 × 4 square.
In the third sample, the maximum possible square is 1 × 1 and can be taken simply as any of the planks. | instruction | 0 | 52,314 | 8 | 104,628 |
Tags: implementation
Correct Solution:
```
k = int(input())
for _ in range(k):
n = int(input())
a = list(map(int, input().split()))
a.sort(reverse=True)
ans = 0
for i in range(n):
ans = max(ans, min(a[i], i+1))
print(ans)
``` | output | 1 | 52,314 | 8 | 104,629 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ujan decided to make a new wooden roof for the house. He has n rectangular planks numbered from 1 to n. The i-th plank has size a_i × 1 (that is, the width is 1 and the height is a_i).
Now, Ujan wants to make a square roof. He will first choose some of the planks and place them side by side in some order. Then he will glue together all of these planks by their vertical sides. Finally, he will cut out a square from the resulting shape in such a way that the sides of the square are horizontal and vertical.
For example, if Ujan had planks with lengths 4, 3, 1, 4 and 5, he could choose planks with lengths 4, 3 and 5. Then he can cut out a 3 × 3 square, which is the maximum possible. Note that this is not the only way he can obtain a 3 × 3 square.
<image>
What is the maximum side length of the square Ujan can get?
Input
The first line of input contains a single integer k (1 ≤ k ≤ 10), the number of test cases in the input.
For each test case, the first line contains a single integer n (1 ≤ n ≤ 1 000), the number of planks Ujan has in store. The next line contains n integers a_1, …, a_n (1 ≤ a_i ≤ n), the lengths of the planks.
Output
For each of the test cases, output a single integer, the maximum possible side length of the square.
Example
Input
4
5
4 3 1 4 5
4
4 4 4 4
3
1 1 1
5
5 5 1 1 5
Output
3
4
1
3
Note
The first sample corresponds to the example in the statement.
In the second sample, gluing all 4 planks will result in a 4 × 4 square.
In the third sample, the maximum possible square is 1 × 1 and can be taken simply as any of the planks. | instruction | 0 | 52,315 | 8 | 104,630 |
Tags: implementation
Correct Solution:
```
import sys
import math
#to faster python
Input=sys.stdin.readline
get_list = lambda: list( map(int,sys.stdin.readline().strip().split()) )
#to read non spaced string and elements are integers to list of int
get_int = lambda: int(sys.stdin.readline().strip())
#to print faster
pt = lambda x: sys.stdout.write(str(x))
for _ in range(get_int()):
a = get_int()
b = get_list()
b.sort()
b.reverse()
sum_1=0
for j in range(a):
if b[j] >= j+1:
sum_1+=1
print(sum_1)
``` | output | 1 | 52,315 | 8 | 104,631 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ujan decided to make a new wooden roof for the house. He has n rectangular planks numbered from 1 to n. The i-th plank has size a_i × 1 (that is, the width is 1 and the height is a_i).
Now, Ujan wants to make a square roof. He will first choose some of the planks and place them side by side in some order. Then he will glue together all of these planks by their vertical sides. Finally, he will cut out a square from the resulting shape in such a way that the sides of the square are horizontal and vertical.
For example, if Ujan had planks with lengths 4, 3, 1, 4 and 5, he could choose planks with lengths 4, 3 and 5. Then he can cut out a 3 × 3 square, which is the maximum possible. Note that this is not the only way he can obtain a 3 × 3 square.
<image>
What is the maximum side length of the square Ujan can get?
Input
The first line of input contains a single integer k (1 ≤ k ≤ 10), the number of test cases in the input.
For each test case, the first line contains a single integer n (1 ≤ n ≤ 1 000), the number of planks Ujan has in store. The next line contains n integers a_1, …, a_n (1 ≤ a_i ≤ n), the lengths of the planks.
Output
For each of the test cases, output a single integer, the maximum possible side length of the square.
Example
Input
4
5
4 3 1 4 5
4
4 4 4 4
3
1 1 1
5
5 5 1 1 5
Output
3
4
1
3
Note
The first sample corresponds to the example in the statement.
In the second sample, gluing all 4 planks will result in a 4 × 4 square.
In the third sample, the maximum possible square is 1 × 1 and can be taken simply as any of the planks. | instruction | 0 | 52,316 | 8 | 104,632 |
Tags: implementation
Correct Solution:
```
n = int(input())
for nn in range(n):
n_of_elements = int(input())
list_of_elements = sorted(list(map(int, input().split())))
for el in range(n_of_elements, 0, -1):
if el <= list_of_elements[n_of_elements - el]:
print(el)
break
``` | output | 1 | 52,316 | 8 | 104,633 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ujan decided to make a new wooden roof for the house. He has n rectangular planks numbered from 1 to n. The i-th plank has size a_i × 1 (that is, the width is 1 and the height is a_i).
Now, Ujan wants to make a square roof. He will first choose some of the planks and place them side by side in some order. Then he will glue together all of these planks by their vertical sides. Finally, he will cut out a square from the resulting shape in such a way that the sides of the square are horizontal and vertical.
For example, if Ujan had planks with lengths 4, 3, 1, 4 and 5, he could choose planks with lengths 4, 3 and 5. Then he can cut out a 3 × 3 square, which is the maximum possible. Note that this is not the only way he can obtain a 3 × 3 square.
<image>
What is the maximum side length of the square Ujan can get?
Input
The first line of input contains a single integer k (1 ≤ k ≤ 10), the number of test cases in the input.
For each test case, the first line contains a single integer n (1 ≤ n ≤ 1 000), the number of planks Ujan has in store. The next line contains n integers a_1, …, a_n (1 ≤ a_i ≤ n), the lengths of the planks.
Output
For each of the test cases, output a single integer, the maximum possible side length of the square.
Example
Input
4
5
4 3 1 4 5
4
4 4 4 4
3
1 1 1
5
5 5 1 1 5
Output
3
4
1
3
Note
The first sample corresponds to the example in the statement.
In the second sample, gluing all 4 planks will result in a 4 × 4 square.
In the third sample, the maximum possible square is 1 × 1 and can be taken simply as any of the planks. | instruction | 0 | 52,317 | 8 | 104,634 |
Tags: implementation
Correct Solution:
```
'''
Created on 2019. 9. 21.
@author: kkhh88
'''
#q = int(input())
#x, y = map(int,input().split(' '))
#print (' '.join(list(map(str, s))))
q = int(input())
for _ in range(q):
n = int(input())
s = list(map(int,input().split(' ')))
s.sort(reverse = True)
cnt = 0
for d in s:
if d >= cnt + 1:
cnt = cnt + 1
else:
break
print (cnt)
``` | output | 1 | 52,317 | 8 | 104,635 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ujan decided to make a new wooden roof for the house. He has n rectangular planks numbered from 1 to n. The i-th plank has size a_i × 1 (that is, the width is 1 and the height is a_i).
Now, Ujan wants to make a square roof. He will first choose some of the planks and place them side by side in some order. Then he will glue together all of these planks by their vertical sides. Finally, he will cut out a square from the resulting shape in such a way that the sides of the square are horizontal and vertical.
For example, if Ujan had planks with lengths 4, 3, 1, 4 and 5, he could choose planks with lengths 4, 3 and 5. Then he can cut out a 3 × 3 square, which is the maximum possible. Note that this is not the only way he can obtain a 3 × 3 square.
<image>
What is the maximum side length of the square Ujan can get?
Input
The first line of input contains a single integer k (1 ≤ k ≤ 10), the number of test cases in the input.
For each test case, the first line contains a single integer n (1 ≤ n ≤ 1 000), the number of planks Ujan has in store. The next line contains n integers a_1, …, a_n (1 ≤ a_i ≤ n), the lengths of the planks.
Output
For each of the test cases, output a single integer, the maximum possible side length of the square.
Example
Input
4
5
4 3 1 4 5
4
4 4 4 4
3
1 1 1
5
5 5 1 1 5
Output
3
4
1
3
Note
The first sample corresponds to the example in the statement.
In the second sample, gluing all 4 planks will result in a 4 × 4 square.
In the third sample, the maximum possible square is 1 × 1 and can be taken simply as any of the planks. | instruction | 0 | 52,318 | 8 | 104,636 |
Tags: implementation
Correct Solution:
```
k = int(input())
for i in range(k):
n = int(input())
a = reversed(sorted(list(map(int, input().split()))))
ret, w = 1, 1
for i in a:
m = min(w, i)
ret = max(m, ret)
w += 1
print(ret)
``` | output | 1 | 52,318 | 8 | 104,637 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ujan decided to make a new wooden roof for the house. He has n rectangular planks numbered from 1 to n. The i-th plank has size a_i × 1 (that is, the width is 1 and the height is a_i).
Now, Ujan wants to make a square roof. He will first choose some of the planks and place them side by side in some order. Then he will glue together all of these planks by their vertical sides. Finally, he will cut out a square from the resulting shape in such a way that the sides of the square are horizontal and vertical.
For example, if Ujan had planks with lengths 4, 3, 1, 4 and 5, he could choose planks with lengths 4, 3 and 5. Then he can cut out a 3 × 3 square, which is the maximum possible. Note that this is not the only way he can obtain a 3 × 3 square.
<image>
What is the maximum side length of the square Ujan can get?
Input
The first line of input contains a single integer k (1 ≤ k ≤ 10), the number of test cases in the input.
For each test case, the first line contains a single integer n (1 ≤ n ≤ 1 000), the number of planks Ujan has in store. The next line contains n integers a_1, …, a_n (1 ≤ a_i ≤ n), the lengths of the planks.
Output
For each of the test cases, output a single integer, the maximum possible side length of the square.
Example
Input
4
5
4 3 1 4 5
4
4 4 4 4
3
1 1 1
5
5 5 1 1 5
Output
3
4
1
3
Note
The first sample corresponds to the example in the statement.
In the second sample, gluing all 4 planks will result in a 4 × 4 square.
In the third sample, the maximum possible square is 1 × 1 and can be taken simply as any of the planks. | instruction | 0 | 52,319 | 8 | 104,638 |
Tags: implementation
Correct Solution:
```
t=int(input())
while t:
t-=1
n=int(input())
s=input()
L=s.split(" ")
for i in range(n):
L[i]=int(L[i])
L.sort()
maxi=0
for i in range(n):
ini=n-i-1
if(i+1<=int(L[ini])):
maxi+=1
else:
break
print(maxi)
``` | output | 1 | 52,319 | 8 | 104,639 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ujan decided to make a new wooden roof for the house. He has n rectangular planks numbered from 1 to n. The i-th plank has size a_i × 1 (that is, the width is 1 and the height is a_i).
Now, Ujan wants to make a square roof. He will first choose some of the planks and place them side by side in some order. Then he will glue together all of these planks by their vertical sides. Finally, he will cut out a square from the resulting shape in such a way that the sides of the square are horizontal and vertical.
For example, if Ujan had planks with lengths 4, 3, 1, 4 and 5, he could choose planks with lengths 4, 3 and 5. Then he can cut out a 3 × 3 square, which is the maximum possible. Note that this is not the only way he can obtain a 3 × 3 square.
<image>
What is the maximum side length of the square Ujan can get?
Input
The first line of input contains a single integer k (1 ≤ k ≤ 10), the number of test cases in the input.
For each test case, the first line contains a single integer n (1 ≤ n ≤ 1 000), the number of planks Ujan has in store. The next line contains n integers a_1, …, a_n (1 ≤ a_i ≤ n), the lengths of the planks.
Output
For each of the test cases, output a single integer, the maximum possible side length of the square.
Example
Input
4
5
4 3 1 4 5
4
4 4 4 4
3
1 1 1
5
5 5 1 1 5
Output
3
4
1
3
Note
The first sample corresponds to the example in the statement.
In the second sample, gluing all 4 planks will result in a 4 × 4 square.
In the third sample, the maximum possible square is 1 × 1 and can be taken simply as any of the planks. | instruction | 0 | 52,320 | 8 | 104,640 |
Tags: implementation
Correct Solution:
```
for _ in range(int(input())):
n=int(input())
l=list(map(int,input().split()))
l.sort()
l.reverse()
# print(l)
a=None
v=[]
for i in range(1,len(l)+1):
v.append(min(i,l[i-1]))
# print(v)
print(max(v))
v.clear()
``` | output | 1 | 52,320 | 8 | 104,641 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ujan decided to make a new wooden roof for the house. He has n rectangular planks numbered from 1 to n. The i-th plank has size a_i × 1 (that is, the width is 1 and the height is a_i).
Now, Ujan wants to make a square roof. He will first choose some of the planks and place them side by side in some order. Then he will glue together all of these planks by their vertical sides. Finally, he will cut out a square from the resulting shape in such a way that the sides of the square are horizontal and vertical.
For example, if Ujan had planks with lengths 4, 3, 1, 4 and 5, he could choose planks with lengths 4, 3 and 5. Then he can cut out a 3 × 3 square, which is the maximum possible. Note that this is not the only way he can obtain a 3 × 3 square.
<image>
What is the maximum side length of the square Ujan can get?
Input
The first line of input contains a single integer k (1 ≤ k ≤ 10), the number of test cases in the input.
For each test case, the first line contains a single integer n (1 ≤ n ≤ 1 000), the number of planks Ujan has in store. The next line contains n integers a_1, …, a_n (1 ≤ a_i ≤ n), the lengths of the planks.
Output
For each of the test cases, output a single integer, the maximum possible side length of the square.
Example
Input
4
5
4 3 1 4 5
4
4 4 4 4
3
1 1 1
5
5 5 1 1 5
Output
3
4
1
3
Note
The first sample corresponds to the example in the statement.
In the second sample, gluing all 4 planks will result in a 4 × 4 square.
In the third sample, the maximum possible square is 1 × 1 and can be taken simply as any of the planks. | instruction | 0 | 52,321 | 8 | 104,642 |
Tags: implementation
Correct Solution:
```
for _ in range(int(input())):
n = int(input())
arr = list(map(int,input().split()))
arr.sort()
arr = arr[-1::-1]
cnt = 1
final = []
for i in range(n):
l = min(arr[:cnt])
ans = min(l,cnt)
final.append(ans)
cnt+=1
print(max(final))
``` | output | 1 | 52,321 | 8 | 104,643 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ujan decided to make a new wooden roof for the house. He has n rectangular planks numbered from 1 to n. The i-th plank has size a_i × 1 (that is, the width is 1 and the height is a_i).
Now, Ujan wants to make a square roof. He will first choose some of the planks and place them side by side in some order. Then he will glue together all of these planks by their vertical sides. Finally, he will cut out a square from the resulting shape in such a way that the sides of the square are horizontal and vertical.
For example, if Ujan had planks with lengths 4, 3, 1, 4 and 5, he could choose planks with lengths 4, 3 and 5. Then he can cut out a 3 × 3 square, which is the maximum possible. Note that this is not the only way he can obtain a 3 × 3 square.
<image>
What is the maximum side length of the square Ujan can get?
Input
The first line of input contains a single integer k (1 ≤ k ≤ 10), the number of test cases in the input.
For each test case, the first line contains a single integer n (1 ≤ n ≤ 1 000), the number of planks Ujan has in store. The next line contains n integers a_1, …, a_n (1 ≤ a_i ≤ n), the lengths of the planks.
Output
For each of the test cases, output a single integer, the maximum possible side length of the square.
Example
Input
4
5
4 3 1 4 5
4
4 4 4 4
3
1 1 1
5
5 5 1 1 5
Output
3
4
1
3
Note
The first sample corresponds to the example in the statement.
In the second sample, gluing all 4 planks will result in a 4 × 4 square.
In the third sample, the maximum possible square is 1 × 1 and can be taken simply as any of the planks.
Submitted Solution:
```
k = int(input())
for i in range(k):
n = int(input())
arr = list(map(int, input().split()))
arr.sort()
for i in range(n):
if min(arr[i:]) >= (n - i):
print(n - i)
break
``` | instruction | 0 | 52,322 | 8 | 104,644 |
Yes | output | 1 | 52,322 | 8 | 104,645 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ujan decided to make a new wooden roof for the house. He has n rectangular planks numbered from 1 to n. The i-th plank has size a_i × 1 (that is, the width is 1 and the height is a_i).
Now, Ujan wants to make a square roof. He will first choose some of the planks and place them side by side in some order. Then he will glue together all of these planks by their vertical sides. Finally, he will cut out a square from the resulting shape in such a way that the sides of the square are horizontal and vertical.
For example, if Ujan had planks with lengths 4, 3, 1, 4 and 5, he could choose planks with lengths 4, 3 and 5. Then he can cut out a 3 × 3 square, which is the maximum possible. Note that this is not the only way he can obtain a 3 × 3 square.
<image>
What is the maximum side length of the square Ujan can get?
Input
The first line of input contains a single integer k (1 ≤ k ≤ 10), the number of test cases in the input.
For each test case, the first line contains a single integer n (1 ≤ n ≤ 1 000), the number of planks Ujan has in store. The next line contains n integers a_1, …, a_n (1 ≤ a_i ≤ n), the lengths of the planks.
Output
For each of the test cases, output a single integer, the maximum possible side length of the square.
Example
Input
4
5
4 3 1 4 5
4
4 4 4 4
3
1 1 1
5
5 5 1 1 5
Output
3
4
1
3
Note
The first sample corresponds to the example in the statement.
In the second sample, gluing all 4 planks will result in a 4 × 4 square.
In the third sample, the maximum possible square is 1 × 1 and can be taken simply as any of the planks.
Submitted Solution:
```
from sys import stdin
def main():
input = lambda: stdin.readline()[:-1]
K = int(input())
for _ in [0] * K:
N = int(input())
A = list(map(int, input().split()))
A.sort(reverse=1)
for i, j in enumerate(A, start=1):
if i > j:
print(i - 1)
break
else:
print(i)
main()
``` | instruction | 0 | 52,323 | 8 | 104,646 |
Yes | output | 1 | 52,323 | 8 | 104,647 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ujan decided to make a new wooden roof for the house. He has n rectangular planks numbered from 1 to n. The i-th plank has size a_i × 1 (that is, the width is 1 and the height is a_i).
Now, Ujan wants to make a square roof. He will first choose some of the planks and place them side by side in some order. Then he will glue together all of these planks by their vertical sides. Finally, he will cut out a square from the resulting shape in such a way that the sides of the square are horizontal and vertical.
For example, if Ujan had planks with lengths 4, 3, 1, 4 and 5, he could choose planks with lengths 4, 3 and 5. Then he can cut out a 3 × 3 square, which is the maximum possible. Note that this is not the only way he can obtain a 3 × 3 square.
<image>
What is the maximum side length of the square Ujan can get?
Input
The first line of input contains a single integer k (1 ≤ k ≤ 10), the number of test cases in the input.
For each test case, the first line contains a single integer n (1 ≤ n ≤ 1 000), the number of planks Ujan has in store. The next line contains n integers a_1, …, a_n (1 ≤ a_i ≤ n), the lengths of the planks.
Output
For each of the test cases, output a single integer, the maximum possible side length of the square.
Example
Input
4
5
4 3 1 4 5
4
4 4 4 4
3
1 1 1
5
5 5 1 1 5
Output
3
4
1
3
Note
The first sample corresponds to the example in the statement.
In the second sample, gluing all 4 planks will result in a 4 × 4 square.
In the third sample, the maximum possible square is 1 × 1 and can be taken simply as any of the planks.
Submitted Solution:
```
'''
4
5
4 3 1 4 5
4
4 4 4 4
3
1 1 1
5
5 5 1 1 5
'''
n=int(input())
for i in range(0,n):
o=int(input())
G=0;
p=input().rstrip().split(' ')
p.sort(key=int,reverse=True)
for j in range(o,-1,-1):
A=p[0:j]
if int(A[len(A)-1]) >= j:
tot=j;
break;
print(tot)
``` | instruction | 0 | 52,324 | 8 | 104,648 |
Yes | output | 1 | 52,324 | 8 | 104,649 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ujan decided to make a new wooden roof for the house. He has n rectangular planks numbered from 1 to n. The i-th plank has size a_i × 1 (that is, the width is 1 and the height is a_i).
Now, Ujan wants to make a square roof. He will first choose some of the planks and place them side by side in some order. Then he will glue together all of these planks by their vertical sides. Finally, he will cut out a square from the resulting shape in such a way that the sides of the square are horizontal and vertical.
For example, if Ujan had planks with lengths 4, 3, 1, 4 and 5, he could choose planks with lengths 4, 3 and 5. Then he can cut out a 3 × 3 square, which is the maximum possible. Note that this is not the only way he can obtain a 3 × 3 square.
<image>
What is the maximum side length of the square Ujan can get?
Input
The first line of input contains a single integer k (1 ≤ k ≤ 10), the number of test cases in the input.
For each test case, the first line contains a single integer n (1 ≤ n ≤ 1 000), the number of planks Ujan has in store. The next line contains n integers a_1, …, a_n (1 ≤ a_i ≤ n), the lengths of the planks.
Output
For each of the test cases, output a single integer, the maximum possible side length of the square.
Example
Input
4
5
4 3 1 4 5
4
4 4 4 4
3
1 1 1
5
5 5 1 1 5
Output
3
4
1
3
Note
The first sample corresponds to the example in the statement.
In the second sample, gluing all 4 planks will result in a 4 × 4 square.
In the third sample, the maximum possible square is 1 × 1 and can be taken simply as any of the planks.
Submitted Solution:
```
t=int(input());
for x in range(t):
num=int(input());
lengthlist=[];
lengthstring=input();
lengthlist=list(lengthstring.split());
for i in range(len(lengthlist)):
lengthlist[i]=int(lengthlist[i])
lengthlist.sort(reverse=True); #sorts from biggest to smallest
biggest=(lengthlist[0]);
for i in range(len(lengthlist)):
if ((lengthlist[biggest-i-1])>=(biggest-i)): #(biggest-i) is the width of all the boards (# of boards); lengthlist[biggest-i-1] is the length of the shortest board that we're looking at
print(biggest-i);
break
``` | instruction | 0 | 52,325 | 8 | 104,650 |
Yes | output | 1 | 52,325 | 8 | 104,651 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ujan decided to make a new wooden roof for the house. He has n rectangular planks numbered from 1 to n. The i-th plank has size a_i × 1 (that is, the width is 1 and the height is a_i).
Now, Ujan wants to make a square roof. He will first choose some of the planks and place them side by side in some order. Then he will glue together all of these planks by their vertical sides. Finally, he will cut out a square from the resulting shape in such a way that the sides of the square are horizontal and vertical.
For example, if Ujan had planks with lengths 4, 3, 1, 4 and 5, he could choose planks with lengths 4, 3 and 5. Then he can cut out a 3 × 3 square, which is the maximum possible. Note that this is not the only way he can obtain a 3 × 3 square.
<image>
What is the maximum side length of the square Ujan can get?
Input
The first line of input contains a single integer k (1 ≤ k ≤ 10), the number of test cases in the input.
For each test case, the first line contains a single integer n (1 ≤ n ≤ 1 000), the number of planks Ujan has in store. The next line contains n integers a_1, …, a_n (1 ≤ a_i ≤ n), the lengths of the planks.
Output
For each of the test cases, output a single integer, the maximum possible side length of the square.
Example
Input
4
5
4 3 1 4 5
4
4 4 4 4
3
1 1 1
5
5 5 1 1 5
Output
3
4
1
3
Note
The first sample corresponds to the example in the statement.
In the second sample, gluing all 4 planks will result in a 4 × 4 square.
In the third sample, the maximum possible square is 1 × 1 and can be taken simply as any of the planks.
Submitted Solution:
```
t=int(input())
for i in range(t):
n=int(input())
lis=list(map(int,input().split()))
maxi=0
l=1
r=max(lis)
while(l<r):
mid=int((l+r)/2)
count =0
for j in lis:
if(j>=mid):
count=count+1
if(count>=mid):
l=mid+1
elif(count<mid):
r=mid-1
print(min(r,l) )
``` | instruction | 0 | 52,326 | 8 | 104,652 |
No | output | 1 | 52,326 | 8 | 104,653 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ujan decided to make a new wooden roof for the house. He has n rectangular planks numbered from 1 to n. The i-th plank has size a_i × 1 (that is, the width is 1 and the height is a_i).
Now, Ujan wants to make a square roof. He will first choose some of the planks and place them side by side in some order. Then he will glue together all of these planks by their vertical sides. Finally, he will cut out a square from the resulting shape in such a way that the sides of the square are horizontal and vertical.
For example, if Ujan had planks with lengths 4, 3, 1, 4 and 5, he could choose planks with lengths 4, 3 and 5. Then he can cut out a 3 × 3 square, which is the maximum possible. Note that this is not the only way he can obtain a 3 × 3 square.
<image>
What is the maximum side length of the square Ujan can get?
Input
The first line of input contains a single integer k (1 ≤ k ≤ 10), the number of test cases in the input.
For each test case, the first line contains a single integer n (1 ≤ n ≤ 1 000), the number of planks Ujan has in store. The next line contains n integers a_1, …, a_n (1 ≤ a_i ≤ n), the lengths of the planks.
Output
For each of the test cases, output a single integer, the maximum possible side length of the square.
Example
Input
4
5
4 3 1 4 5
4
4 4 4 4
3
1 1 1
5
5 5 1 1 5
Output
3
4
1
3
Note
The first sample corresponds to the example in the statement.
In the second sample, gluing all 4 planks will result in a 4 × 4 square.
In the third sample, the maximum possible square is 1 × 1 and can be taken simply as any of the planks.
Submitted Solution:
```
for c in range(int(input())):
n = int(input())
lengths = sorted(list(map(int, input().split())))
count = 0
p = 0
maxLs = []
x = True
for i in range(n):
if (n - i) >= lengths[i]:
maxLs.append(lengths[i])
else:
for m in range(n-i, n):
if lengths[m] < (n - i):
x = False
if x:
maxLs.append(n - i)
break
print(max(maxLs))
``` | instruction | 0 | 52,327 | 8 | 104,654 |
No | output | 1 | 52,327 | 8 | 104,655 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ujan decided to make a new wooden roof for the house. He has n rectangular planks numbered from 1 to n. The i-th plank has size a_i × 1 (that is, the width is 1 and the height is a_i).
Now, Ujan wants to make a square roof. He will first choose some of the planks and place them side by side in some order. Then he will glue together all of these planks by their vertical sides. Finally, he will cut out a square from the resulting shape in such a way that the sides of the square are horizontal and vertical.
For example, if Ujan had planks with lengths 4, 3, 1, 4 and 5, he could choose planks with lengths 4, 3 and 5. Then he can cut out a 3 × 3 square, which is the maximum possible. Note that this is not the only way he can obtain a 3 × 3 square.
<image>
What is the maximum side length of the square Ujan can get?
Input
The first line of input contains a single integer k (1 ≤ k ≤ 10), the number of test cases in the input.
For each test case, the first line contains a single integer n (1 ≤ n ≤ 1 000), the number of planks Ujan has in store. The next line contains n integers a_1, …, a_n (1 ≤ a_i ≤ n), the lengths of the planks.
Output
For each of the test cases, output a single integer, the maximum possible side length of the square.
Example
Input
4
5
4 3 1 4 5
4
4 4 4 4
3
1 1 1
5
5 5 1 1 5
Output
3
4
1
3
Note
The first sample corresponds to the example in the statement.
In the second sample, gluing all 4 planks will result in a 4 × 4 square.
In the third sample, the maximum possible square is 1 × 1 and can be taken simply as any of the planks.
Submitted Solution:
```
k = int(input())
for j in range(k):
nboards = int(input())
l = list(map(int, input().split(' ')))
for i in range(len(l)):
if l[i] < i+1:
print(i)
break
elif l[-1] == len(l):
print(len(l))
``` | instruction | 0 | 52,328 | 8 | 104,656 |
No | output | 1 | 52,328 | 8 | 104,657 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ujan decided to make a new wooden roof for the house. He has n rectangular planks numbered from 1 to n. The i-th plank has size a_i × 1 (that is, the width is 1 and the height is a_i).
Now, Ujan wants to make a square roof. He will first choose some of the planks and place them side by side in some order. Then he will glue together all of these planks by their vertical sides. Finally, he will cut out a square from the resulting shape in such a way that the sides of the square are horizontal and vertical.
For example, if Ujan had planks with lengths 4, 3, 1, 4 and 5, he could choose planks with lengths 4, 3 and 5. Then he can cut out a 3 × 3 square, which is the maximum possible. Note that this is not the only way he can obtain a 3 × 3 square.
<image>
What is the maximum side length of the square Ujan can get?
Input
The first line of input contains a single integer k (1 ≤ k ≤ 10), the number of test cases in the input.
For each test case, the first line contains a single integer n (1 ≤ n ≤ 1 000), the number of planks Ujan has in store. The next line contains n integers a_1, …, a_n (1 ≤ a_i ≤ n), the lengths of the planks.
Output
For each of the test cases, output a single integer, the maximum possible side length of the square.
Example
Input
4
5
4 3 1 4 5
4
4 4 4 4
3
1 1 1
5
5 5 1 1 5
Output
3
4
1
3
Note
The first sample corresponds to the example in the statement.
In the second sample, gluing all 4 planks will result in a 4 × 4 square.
In the third sample, the maximum possible square is 1 × 1 and can be taken simply as any of the planks.
Submitted Solution:
```
k = int(input())
n = 0
a = []
for c in range(k):
n = int(input())
a = [int(s) for s in input().split()]
a.sort(reverse=True)
for i in range(n):
if a[i] <= i:
print(i)
break
if i == n - 1:
if a[i] == n: print(a[i])
else: print('1')
``` | instruction | 0 | 52,329 | 8 | 104,658 |
No | output | 1 | 52,329 | 8 | 104,659 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is an area map that is a rectangular matrix n × m, each cell of the matrix contains the average height of a corresponding area part. Peter works for a company that has to build several cities within this area, each of the cities will occupy a rectangle a × b cells on the map. To start construction works in a particular place Peter needs to remove excess ground from the construction site where a new city will be built. To do so he chooses a cell of the minimum height within this site, and removes excess ground from other cells of the site down to this minimum level. Let's consider that to lower the ground level from h2 to h1 (h1 ≤ h2) they need to remove h2 - h1 ground units.
Let's call a site's position optimal, if the amount of the ground removed from this site is minimal compared to other possible positions. Peter constructs cities according to the following algorithm: from all the optimum site's positions he chooses the uppermost one. If this position is not unique, he chooses the leftmost one. Then he builds a city on this site. Peter repeats this process untill he can build at least one more city. For sure, he cannot carry out construction works on the occupied cells. Would you, please, help Peter place cities according to the algorithm?
Input
The first line contains four space-separated integers: map sizes n, m and city sizes a, b (1 ≤ a ≤ n ≤ 1000, 1 ≤ b ≤ m ≤ 1000). Then there follow n lines, each contains m non-negative space-separated numbers, describing the height matrix. Each number doesn't exceed 109.
Output
In the first line output k — the amount of constructed cities. In each of the following k lines output 3 space-separated numbers — the row number and the column number of the upper-left corner of a subsequent construction site, and the amount of the ground to remove from it. Output the sites in the order of their building up.
Examples
Input
2 2 1 2
1 2
3 5
Output
2
1 1 1
2 1 2
Input
4 4 2 2
1 5 3 4
2 7 6 1
1 1 2 2
2 2 1 2
Output
3
3 1 2
3 3 3
1 2 9
Submitted Solution:
```
def Valuation(mp, i, j, n, m, a, b):
hight = list()
for r in range(i, i+a):
if r >= n:
return -1
for c in range(j, j+b):
if c >= m:
return -1
# print(r,c)
hight.append(mp[r][c])
# print(hight)
min_ = min(hight)
cost = 0
for val in hight:
cost += val - min_
return cost
def Check(city, mp, a, b):
for r in range(city[0], city[0]+a):
for c in range(city[1], city[1]+b):
if mp[r][c] == -100:
return False
return True
def Occupy(city):
for r in range(city[0], city[0]+a):
for c in range(city[1], city[1]+b):
mp[r][c] = -100
if __name__ == '__main__':
# n, m, a, b = [int(x) for x in input().split()]
# h = [[int(j) for j in input().split()] for _ in range(n)]
n, m, a, b = list(map(int, input().split()))
mp = [[int(j) for j in input().split()] for _ in range(n)]
# print("\nInput:", n, m, a, b, mp)
costs = list()
for i in range(n):
for j in range(m):
val = Valuation(mp, i, j, n, m, a, b)
costs.append([i, j, val])
# print(costs)
# costs.sort(key=lambda cost:cost[0], reverse=True)
costs.sort(key=lambda cost:cost[1], reverse=True)
costs.sort(key=lambda cost:cost[2], reverse=True)
# for i in range(len(costs)-1):
# if costs[i][2] == costs[i+1][2]:
# if costs[i][0] < costs[i+1][0]:
# costs[i], costs[i+1] = costs[i+1], costs[i]
# elif costs[i][0] == costs[i+1][0] and costs[i][1] < costs[i+1][1]:
# costs[i], costs[i+1] = costs[i+1], costs[i]
# print(costs)
ans = list()
while len(costs) != 0:
city = costs.pop()
if city[2] != -1 and Check(city, mp, a, b):
Occupy(city)
city[0] += 1
city[1] += 1
ans.append(city)
print(len(ans))
for city in ans:
for i in range(3):
print(city[i], end = " ")
print()
# print(ans)
# print(costs)
``` | instruction | 0 | 52,471 | 8 | 104,942 |
No | output | 1 | 52,471 | 8 | 104,943 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is an area map that is a rectangular matrix n × m, each cell of the matrix contains the average height of a corresponding area part. Peter works for a company that has to build several cities within this area, each of the cities will occupy a rectangle a × b cells on the map. To start construction works in a particular place Peter needs to remove excess ground from the construction site where a new city will be built. To do so he chooses a cell of the minimum height within this site, and removes excess ground from other cells of the site down to this minimum level. Let's consider that to lower the ground level from h2 to h1 (h1 ≤ h2) they need to remove h2 - h1 ground units.
Let's call a site's position optimal, if the amount of the ground removed from this site is minimal compared to other possible positions. Peter constructs cities according to the following algorithm: from all the optimum site's positions he chooses the uppermost one. If this position is not unique, he chooses the leftmost one. Then he builds a city on this site. Peter repeats this process untill he can build at least one more city. For sure, he cannot carry out construction works on the occupied cells. Would you, please, help Peter place cities according to the algorithm?
Input
The first line contains four space-separated integers: map sizes n, m and city sizes a, b (1 ≤ a ≤ n ≤ 1000, 1 ≤ b ≤ m ≤ 1000). Then there follow n lines, each contains m non-negative space-separated numbers, describing the height matrix. Each number doesn't exceed 109.
Output
In the first line output k — the amount of constructed cities. In each of the following k lines output 3 space-separated numbers — the row number and the column number of the upper-left corner of a subsequent construction site, and the amount of the ground to remove from it. Output the sites in the order of their building up.
Examples
Input
2 2 1 2
1 2
3 5
Output
2
1 1 1
2 1 2
Input
4 4 2 2
1 5 3 4
2 7 6 1
1 1 2 2
2 2 1 2
Output
3
3 1 2
3 3 3
1 2 9
Submitted Solution:
```
from functools import cmp_to_key
from operator import itemgetter, attrgetter
def Valuation(mp, i, j, n, m, a, b):
hight = list()
for r in range(i, i+a):
if r >= n:
return -1
for c in range(j, j+b):
if c >= m:
return -1
# print(r,c)
hight.append(mp[r][c])
# print(hight)
min_ = min(hight)
cost = 0
for val in hight:
cost += val - min_
return cost
def Check(city, mp, a, b):
for r in range(city[0], city[0]+a):
for c in range(city[1], city[1]+b):
if mp[r][c] == -100:
return False
return True
def Occupy(city):
for r in range(city[0], city[0]+a):
for c in range(city[1], city[1]+b):
mp[r][c] = -100
def Cmp(a, b):
if a[2] < b[2]:
# print('Before: ', costs[i], costs[i+1])
return 1
# print('After: ', costs[i], costs[i+1])
elif a[2] == b[2]:
if a[0] < b[0]:
return 1
elif a[0] == b[0] and a[1] < b[1]:
# print(costs[i], costs[i+1])
return 1
return -1
# cmp_items_py3 = cmp_to_key(Cmp)
if __name__ == '__main__':
# n, m, a, b = [int(x) for x in input().split()]
# h = [[int(j) for j in input().split()] for _ in range(n)]
n, m, a, b = list(map(int, input().split()))
mp = [[int(j) for j in input().split()] for _ in range(n)]
# print("\nInput:", n, m, a, b, mp)
costs = list()
for i in range(n):
for j in range(m):
val = Valuation(mp, i, j, n, m, a, b)
costs.append([i, j, val])
# print(costs)
# costs.sort(key=lambda cost:cost[1], reverse=True)
# costs.sort(key=lambda cost:cost[0], reverse=True)
print("Before:", costs)
# costs.sort(Cmp)
costs = sorted(costs, key=itemgetter(2, 0, 1), reverse=True)
# print("Before:", costs)
# for j in range(1, len(costs)):
# for i in range(len(costs)-j):
# if costs[i][2] < costs[i+1][2]:
# # print('Before: ', costs[i], costs[i+1])
# costs[i], costs[i+1] = costs[i+1], costs[i]
# # print('After: ', costs[i], costs[i+1])
# elif costs[i][2] == costs[i+1][2]:
# if costs[i][0] < costs[i+1][0]:
# costs[i], costs[i+1] = costs[i+1], costs[i]
# elif costs[i][0] == costs[i+1][0] and costs[i][1] < costs[i+1][1]:
# # print(costs[i], costs[i+1])
# costs[i], costs[i+1] = costs[i+1], costs[i]
print("After:", costs)
ans = list()
while len(costs) != 0:
city = costs.pop()
if city[2] != -1 and Check(city, mp, a, b):
Occupy(city)
city[0] += 1
city[1] += 1
ans.append(city)
print(len(ans))
for city in ans:
for i in range(3):
print(city[i], end = " ")
print()
# print(ans)
# print(costs)
``` | instruction | 0 | 52,472 | 8 | 104,944 |
No | output | 1 | 52,472 | 8 | 104,945 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is an area map that is a rectangular matrix n × m, each cell of the matrix contains the average height of a corresponding area part. Peter works for a company that has to build several cities within this area, each of the cities will occupy a rectangle a × b cells on the map. To start construction works in a particular place Peter needs to remove excess ground from the construction site where a new city will be built. To do so he chooses a cell of the minimum height within this site, and removes excess ground from other cells of the site down to this minimum level. Let's consider that to lower the ground level from h2 to h1 (h1 ≤ h2) they need to remove h2 - h1 ground units.
Let's call a site's position optimal, if the amount of the ground removed from this site is minimal compared to other possible positions. Peter constructs cities according to the following algorithm: from all the optimum site's positions he chooses the uppermost one. If this position is not unique, he chooses the leftmost one. Then he builds a city on this site. Peter repeats this process untill he can build at least one more city. For sure, he cannot carry out construction works on the occupied cells. Would you, please, help Peter place cities according to the algorithm?
Input
The first line contains four space-separated integers: map sizes n, m and city sizes a, b (1 ≤ a ≤ n ≤ 1000, 1 ≤ b ≤ m ≤ 1000). Then there follow n lines, each contains m non-negative space-separated numbers, describing the height matrix. Each number doesn't exceed 109.
Output
In the first line output k — the amount of constructed cities. In each of the following k lines output 3 space-separated numbers — the row number and the column number of the upper-left corner of a subsequent construction site, and the amount of the ground to remove from it. Output the sites in the order of their building up.
Examples
Input
2 2 1 2
1 2
3 5
Output
2
1 1 1
2 1 2
Input
4 4 2 2
1 5 3 4
2 7 6 1
1 1 2 2
2 2 1 2
Output
3
3 1 2
3 3 3
1 2 9
Submitted Solution:
```
from collections import deque
def rollingsum(x, k):
y = [None] * (len(x) - k + 1)
y[0] = sum(x[:k])
for i in range(k, len(x)):
y[i-k+1] = y[i-k] + x[i] - x[i-k]
return y
def rollingmin(x, k):
y = [None] * (len(x) - k + 1)
d = deque()
for i in range(len(x)):
while d and d[-1][1] >= x[i]:
d.pop()
while d and d[0][0] <= i - k:
d.popleft()
d.append((i, x[i]))
if i >= k-1:
y[i-k+1] = d[0][1];
return y
n, m, a, b = [int(x) for x in input().split()]
h = [[int(j) for j in input().split()] for _ in range(n)]
hmin = [rollingmin(h[i], b) for i in range(n)]
hsum = [rollingsum(h[i], b) for i in range(n)]
hmin = list(zip(*hmin))
hsum = list(zip(*hsum))
vmin = [rollingmin(hmin[i], a) for i in range(m-b+1)]
vsum = [rollingsum(hsum[i], a) for i in range(m-b+1)]
x = []
for j in range(len(vmin)):
for i in range(len(vmin[0])):
x.append((j, i, vsum[j][i] - vmin[j][i] * a * b))
used = [False] * (n * m)
x.sort(key=lambda x:x[2])
built = []
for c in x:
if used[c[1] * m + c[0]] or used[(c[1]+a-1) * m + c[0] + b-1]:
continue
built.append(c)
for i in range(c[1], c[1] + a):
for j in range(c[0], c[0] + b):
used[i * m + j] = True
print(len(built))
for j, i, r in built:
print(i + 1, j + 1, r)
``` | instruction | 0 | 52,473 | 8 | 104,946 |
No | output | 1 | 52,473 | 8 | 104,947 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is an area map that is a rectangular matrix n × m, each cell of the matrix contains the average height of a corresponding area part. Peter works for a company that has to build several cities within this area, each of the cities will occupy a rectangle a × b cells on the map. To start construction works in a particular place Peter needs to remove excess ground from the construction site where a new city will be built. To do so he chooses a cell of the minimum height within this site, and removes excess ground from other cells of the site down to this minimum level. Let's consider that to lower the ground level from h2 to h1 (h1 ≤ h2) they need to remove h2 - h1 ground units.
Let's call a site's position optimal, if the amount of the ground removed from this site is minimal compared to other possible positions. Peter constructs cities according to the following algorithm: from all the optimum site's positions he chooses the uppermost one. If this position is not unique, he chooses the leftmost one. Then he builds a city on this site. Peter repeats this process untill he can build at least one more city. For sure, he cannot carry out construction works on the occupied cells. Would you, please, help Peter place cities according to the algorithm?
Input
The first line contains four space-separated integers: map sizes n, m and city sizes a, b (1 ≤ a ≤ n ≤ 1000, 1 ≤ b ≤ m ≤ 1000). Then there follow n lines, each contains m non-negative space-separated numbers, describing the height matrix. Each number doesn't exceed 109.
Output
In the first line output k — the amount of constructed cities. In each of the following k lines output 3 space-separated numbers — the row number and the column number of the upper-left corner of a subsequent construction site, and the amount of the ground to remove from it. Output the sites in the order of their building up.
Examples
Input
2 2 1 2
1 2
3 5
Output
2
1 1 1
2 1 2
Input
4 4 2 2
1 5 3 4
2 7 6 1
1 1 2 2
2 2 1 2
Output
3
3 1 2
3 3 3
1 2 9
Submitted Solution:
```
def Valuation(mp, i, j, n, m, a, b):
hight = list()
for r in range(i, i+a):
if r >= n:
return -1
for c in range(j, j+b):
if c >= m:
return -1
# print(r,c)
hight.append(mp[r][c])
# print(hight)
min_ = min(hight)
cost = 0
for val in hight:
cost += val - min_
return cost
def Check(city, mp, a, b):
for r in range(city[0], city[0]+a):
for c in range(city[1], city[1]+b):
if mp[r][c] == -100:
return False
return True
def Occupy(city):
for r in range(city[0], city[0]+a):
for c in range(city[1], city[1]+b):
mp[r][c] = -100
if __name__ == '__main__':
# n, m, a, b = [int(x) for x in input().split()]
# h = [[int(j) for j in input().split()] for _ in range(n)]
n, m, a, b = list(map(int, input().split()))
mp = [[int(j) for j in input().split()] for _ in range(n)]
# print("\nInput:", n, m, a, b, mp)
costs = list()
for i in range(n):
for j in range(m):
val = Valuation(mp, i, j, n, m, a, b)
costs.append([i, j, val])
# print(costs)
costs.sort(key=lambda cost:cost[0], reverse=True)
costs.sort(key=lambda cost:cost[1], reverse=True)
costs.sort(key=lambda cost:cost[2], reverse=True)
for i in range(len(costs)-1):
if costs[i][2] == costs[i+1][2]:
if costs[i][0] < costs[i+1][0]:
costs[i], costs[i+1] = costs[i+1], costs[i]
elif costs[i][0] == costs[i+1][0] and costs[i][1] < costs[i+1][1]:
costs[i], costs[i+1] = costs[i+1], costs[i]
# print(costs)
ans = list()
while len(costs) != 0:
city = costs.pop()
if city[2] != -1 and Check(city, mp, a, b):
Occupy(city)
city[0] += 1
city[1] += 1
ans.append(city)
print(len(ans))
for city in ans:
for i in range(3):
print(city[i], end = " ")
print()
# print(ans)
# print(costs)
``` | instruction | 0 | 52,474 | 8 | 104,948 |
No | output | 1 | 52,474 | 8 | 104,949 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Niwel is a little golden bear. As everyone knows, bears live in forests, but Niwel got tired of seeing all the trees so he decided to move to the city.
In the city, Niwel took on a job managing bears to deliver goods. The city that he lives in can be represented as a directed graph with n nodes and m edges. Each edge has a weight capacity. A delivery consists of a bear carrying weights with their bear hands on a simple path from node 1 to node n. The total weight that travels across a particular edge must not exceed the weight capacity of that edge.
Niwel has exactly x bears. In the interest of fairness, no bear can rest, and the weight that each bear carries must be exactly the same. However, each bear may take different paths if they like.
Niwel would like to determine, what is the maximum amount of weight he can deliver (it's the sum of weights carried by bears). Find the maximum weight.
Input
The first line contains three integers n, m and x (2 ≤ n ≤ 50, 1 ≤ m ≤ 500, 1 ≤ x ≤ 100 000) — the number of nodes, the number of directed edges and the number of bears, respectively.
Each of the following m lines contains three integers ai, bi and ci (1 ≤ ai, bi ≤ n, ai ≠ bi, 1 ≤ ci ≤ 1 000 000). This represents a directed edge from node ai to bi with weight capacity ci. There are no self loops and no multiple edges from one city to the other city. More formally, for each i and j that i ≠ j it's guaranteed that ai ≠ aj or bi ≠ bj. It is also guaranteed that there is at least one path from node 1 to node n.
Output
Print one real value on a single line — the maximum amount of weight Niwel can deliver if he uses exactly x bears. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct if <image>.
Examples
Input
4 4 3
1 2 2
2 4 1
1 3 1
3 4 2
Output
1.5000000000
Input
5 11 23
1 2 3
2 3 4
3 4 5
4 5 6
1 3 4
2 4 5
3 5 6
1 4 2
2 5 3
1 5 2
3 2 30
Output
10.2222222222
Note
In the first sample, Niwel has three bears. Two bears can choose the path <image>, while one bear can choose the path <image>. Even though the bear that goes on the path <image> can carry one unit of weight, in the interest of fairness, he is restricted to carry 0.5 units of weight. Thus, the total weight is 1.5 units overall. Note that even though Niwel can deliver more weight with just 2 bears, he must use exactly 3 bears on this day. | instruction | 0 | 52,636 | 8 | 105,272 |
Tags: binary search, flows, graphs
Correct Solution:
```
from collections import defaultdict, deque
adj = defaultdict(lambda: defaultdict(lambda: 0))
def bfs(graph, inicio, destino, parent):
parent.clear()
queue = deque()
queue.append([inicio, float("Inf")])
parent[inicio] = -2
while (len(queue)):
current, flow = queue.popleft()
for i in adj[current]:
if parent[i] == -1 and graph[current][i] > 0:
parent[i] = current
flow = min(flow, graph[current][i])
if i == destino:
return flow
queue.append((i, flow))
return 0
def maxflow(graph, inicio, destino):
flow = 0
parent = defaultdict(lambda: -1)
while True:
t = bfs(graph, inicio, destino, parent)
if t:
flow += t
current = destino
while current != inicio:
prev = parent[current]
graph[prev][current] -= t
graph[current][prev] += t
current = prev
else:
break
return flow
n, m, x = [int(i) for i in input().split()]
for _ in range(m):
t = [int(i) for i in input().split()]
adj[t[0]][t[1]] = t[2]
def check(k):
meh = defaultdict(lambda: defaultdict(lambda: 0))
for i in adj:
for j in adj[i]:
ww = adj[i][j] // k
meh[i][j] = ww
flow = maxflow(meh, 1, n)
return flow
lo = 1 / x
hi = check(1)
for _ in range(70):
mid = (hi + lo) / 2
if hi-lo<0.0000000001:
break
if check(mid)>=x:
lo = mid
else:
hi = mid
print(format(lo * x, '.9f'))
``` | output | 1 | 52,636 | 8 | 105,273 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Niwel is a little golden bear. As everyone knows, bears live in forests, but Niwel got tired of seeing all the trees so he decided to move to the city.
In the city, Niwel took on a job managing bears to deliver goods. The city that he lives in can be represented as a directed graph with n nodes and m edges. Each edge has a weight capacity. A delivery consists of a bear carrying weights with their bear hands on a simple path from node 1 to node n. The total weight that travels across a particular edge must not exceed the weight capacity of that edge.
Niwel has exactly x bears. In the interest of fairness, no bear can rest, and the weight that each bear carries must be exactly the same. However, each bear may take different paths if they like.
Niwel would like to determine, what is the maximum amount of weight he can deliver (it's the sum of weights carried by bears). Find the maximum weight.
Input
The first line contains three integers n, m and x (2 ≤ n ≤ 50, 1 ≤ m ≤ 500, 1 ≤ x ≤ 100 000) — the number of nodes, the number of directed edges and the number of bears, respectively.
Each of the following m lines contains three integers ai, bi and ci (1 ≤ ai, bi ≤ n, ai ≠ bi, 1 ≤ ci ≤ 1 000 000). This represents a directed edge from node ai to bi with weight capacity ci. There are no self loops and no multiple edges from one city to the other city. More formally, for each i and j that i ≠ j it's guaranteed that ai ≠ aj or bi ≠ bj. It is also guaranteed that there is at least one path from node 1 to node n.
Output
Print one real value on a single line — the maximum amount of weight Niwel can deliver if he uses exactly x bears. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct if <image>.
Examples
Input
4 4 3
1 2 2
2 4 1
1 3 1
3 4 2
Output
1.5000000000
Input
5 11 23
1 2 3
2 3 4
3 4 5
4 5 6
1 3 4
2 4 5
3 5 6
1 4 2
2 5 3
1 5 2
3 2 30
Output
10.2222222222
Note
In the first sample, Niwel has three bears. Two bears can choose the path <image>, while one bear can choose the path <image>. Even though the bear that goes on the path <image> can carry one unit of weight, in the interest of fairness, he is restricted to carry 0.5 units of weight. Thus, the total weight is 1.5 units overall. Note that even though Niwel can deliver more weight with just 2 bears, he must use exactly 3 bears on this day. | instruction | 0 | 52,637 | 8 | 105,274 |
Tags: binary search, flows, graphs
Correct Solution:
```
from queue import Queue
def addEdge(s, t, flow):
E[s].append((len(E[t]), t, flow))
E[t].append((len(E[s])-1, s, 0))
def mkLevel():
global src, des, E, lvl
for i in range(n):
lvl[i] = -1
lvl[src] = 0
q = Queue()
q.put(src)
while (not q.empty()):
cur = q.get()
for j in range(len(E[cur])):
to = E[cur][j][1]
if (lvl[to] < 0 and E[cur][j][2] > 0):
lvl[to] = lvl[cur] + 1
q.put(to)
if (to == des):
return True
return False
def extend(cur, lim):
global des, E
if (lim == 0 or cur == des):
return lim
flow = 0
for j in range(len(E[cur])):
if (flow >= lim):
break
to = E[cur][j][1]
lim0 = min(lim-flow, E[cur][j][2])
if (E[cur][j][2] > 0 and lvl[to] == lvl[cur] + 1):
newf = extend(to, lim0)
if (newf > 0):
E[cur][j] = (E[cur][j][0], E[cur][j][1], E[cur][j][2] - newf)
jj = E[cur][j][0]
E[to][jj] = (E[to][jj][0], E[to][jj][1], E[to][jj][2] + newf)
flow += newf
if (flow == 0):
lvl[cur] = -1
return flow
def Dinic():
# for i in range(len(E)):
# print('i = {} : {}'.format(i, E[i]), flush = True)
flow = 0
newf = 0
while (mkLevel()):
newf = extend(src, INF)
while (newf > 0):
flow += newf
newf = extend(src, INF)
return flow
def check(mid):
global E
E = [[] for i in range(n)]
for i in range(m):
if (w[i] - bears * mid > 0):
addEdge(u[i], v[i], bears)
else:
addEdge(u[i], v[i], int(w[i] / mid))
return (Dinic() >= bears)
n,m,bears = map(int, input().split())
#print(n, m, bears, flush = True)
INF = 0x3f3f3f3f
src = 0
des = n-1
lo = 0.0
hi = 0.0
u = [0 for i in range(m)]
v = [0 for i in range(m)]
w = [0 for i in range(m)]
for i in range(m):
u[i],v[i],w[i] = map(int, input().split())
#print(u[i], v[i], w[i], flush = True)
u[i] -= 1
v[i] -= 1
hi = max(hi, w[i])
E = [[] for i in range(n)]
lvl = [0 for i in range(n)]
for i in range(100):
mid = (lo + hi) / 2
#print('mid = {:.3f}'.format(mid), flush = True)
if (check(mid)):
lo = mid
else:
hi = mid
print('{:.10f}'.format(mid * bears))
``` | output | 1 | 52,637 | 8 | 105,275 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.