message stringlengths 2 65.1k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 0 108k | cluster float64 14 14 | __index_level_0__ int64 0 217k |
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
Iahub helps his grandfather at the farm. Today he must milk the cows. There are n cows sitting in a row, numbered from 1 to n from left to right. Each cow is either facing to the left or facing to the right. When Iahub milks a cow, all the cows that see the current cow get scared and lose one unit of the quantity of milk that they can give. A cow facing left sees all the cows with lower indices than her index, and a cow facing right sees all the cows with higher indices than her index. A cow that got scared once can get scared again (and lose one more unit of milk). A cow that has been milked once cannot get scared and lose any more milk. You can assume that a cow never loses all the milk she can give (a cow gives an infinitely amount of milk).
Iahub can decide the order in which he milks the cows. But he must milk each cow exactly once. Iahub wants to lose as little milk as possible. Print the minimum amount of milk that is lost.
Input
The first line contains an integer n (1 β€ n β€ 200000). The second line contains n integers a1, a2, ..., an, where ai is 0 if the cow number i is facing left, and 1 if it is facing right.
Output
Print a single integer, the minimum amount of lost milk.
Please, do not write the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
4
0 0 1 0
Output
1
Input
5
1 0 1 0 1
Output
3
Note
In the first sample Iahub milks the cows in the following order: cow 3, cow 4, cow 2, cow 1. When he milks cow 3, cow 4 loses 1 unit of milk. After that, no more milk is lost. | instruction | 0 | 96,476 | 14 | 192,952 |
Tags: data structures, greedy
Correct Solution:
```
from collections import *
from math import *
n = int(input())
a = list(map(int,input().split()))
ct0,res0 = 0,0
for i in range(n):
if(a[i] == 1): ct0 += 1
else: res0 += ct0
ct1,res1 = 0,0
for i in range(n-1,-1,-1):
if(a[i] == 0): ct1 += 1
else: res1 += ct1
print(min(res0,res1))
``` | output | 1 | 96,476 | 14 | 192,953 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Iahub helps his grandfather at the farm. Today he must milk the cows. There are n cows sitting in a row, numbered from 1 to n from left to right. Each cow is either facing to the left or facing to the right. When Iahub milks a cow, all the cows that see the current cow get scared and lose one unit of the quantity of milk that they can give. A cow facing left sees all the cows with lower indices than her index, and a cow facing right sees all the cows with higher indices than her index. A cow that got scared once can get scared again (and lose one more unit of milk). A cow that has been milked once cannot get scared and lose any more milk. You can assume that a cow never loses all the milk she can give (a cow gives an infinitely amount of milk).
Iahub can decide the order in which he milks the cows. But he must milk each cow exactly once. Iahub wants to lose as little milk as possible. Print the minimum amount of milk that is lost.
Input
The first line contains an integer n (1 β€ n β€ 200000). The second line contains n integers a1, a2, ..., an, where ai is 0 if the cow number i is facing left, and 1 if it is facing right.
Output
Print a single integer, the minimum amount of lost milk.
Please, do not write the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
4
0 0 1 0
Output
1
Input
5
1 0 1 0 1
Output
3
Note
In the first sample Iahub milks the cows in the following order: cow 3, cow 4, cow 2, cow 1. When he milks cow 3, cow 4 loses 1 unit of milk. After that, no more milk is lost. | instruction | 0 | 96,477 | 14 | 192,954 |
Tags: data structures, greedy
Correct Solution:
```
n = int(input())
lis = list(map(int,input().split()))
ans=b=0
for i in range(n-1,-1,-1):
if lis[i]==1:
ans+=b
else:
b+=1
print(ans)
``` | output | 1 | 96,477 | 14 | 192,955 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Peter decided to wish happy birthday to his friend from Australia and send him a card. To make his present more mysterious, he decided to make a chain. Chain here is such a sequence of envelopes A = {a1, a2, ..., an}, where the width and the height of the i-th envelope is strictly higher than the width and the height of the (i - 1)-th envelope respectively. Chain size is the number of envelopes in the chain.
Peter wants to make the chain of the maximum size from the envelopes he has, the chain should be such, that he'll be able to put a card into it. The card fits into the chain if its width and height is lower than the width and the height of the smallest envelope in the chain respectively. It's forbidden to turn the card and the envelopes.
Peter has very many envelopes and very little time, this hard task is entrusted to you.
Input
The first line contains integers n, w, h (1 β€ n β€ 5000, 1 β€ w, h β€ 106) β amount of envelopes Peter has, the card width and height respectively. Then there follow n lines, each of them contains two integer numbers wi and hi β width and height of the i-th envelope (1 β€ wi, hi β€ 106).
Output
In the first line print the maximum chain size. In the second line print the numbers of the envelopes (separated by space), forming the required chain, starting with the number of the smallest envelope. Remember, please, that the card should fit into the smallest envelope. If the chain of maximum size is not unique, print any of the answers.
If the card does not fit into any of the envelopes, print number 0 in the single line.
Examples
Input
2 1 1
2 2
2 2
Output
1
1
Input
3 3 3
5 4
12 11
9 8
Output
3
1 3 2 | instruction | 0 | 96,526 | 14 | 193,052 |
Tags: dp, sortings
Correct Solution:
```
# -*- coding:utf-8 -*-
"""
created by shuangquan.huang at 1/6/20
"""
import collections
import time
import os
import sys
import bisect
import heapq
from typing import List
def solve(N, W, H, A):
A = [(w, h, i) for i, (w, h) in enumerate(A) if w > W and h > H]
A.sort()
N = len(A)
if N <= 0:
return 0, []
dp = [1 for _ in range(N)]
pre = [-1 for _ in range(N)]
dp[0] = 1
maxsize, maxi = 1, 0
for i in range(1, N):
for j in range(i):
if A[j][0] < A[i][0] and A[j][1] < A[i][1]:
if dp[j] + 1 > dp[i]:
dp[i] = dp[j] + 1
pre[i] = j
if dp[i] > maxsize:
maxsize = dp[i]
maxi = i
path = []
i = maxi
while i >= 0:
path.append(A[i][2] + 1)
i = pre[i]
return maxsize, path[::-1]
N, W, H = map(int, input().split())
A = []
for i in range(N):
w, h = map(int, input().split())
A.append((w, h))
c, p = solve(N, W, H, A)
print(c)
if c > 0:
print(' '.join(map(str, p)))
``` | output | 1 | 96,526 | 14 | 193,053 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Peter decided to wish happy birthday to his friend from Australia and send him a card. To make his present more mysterious, he decided to make a chain. Chain here is such a sequence of envelopes A = {a1, a2, ..., an}, where the width and the height of the i-th envelope is strictly higher than the width and the height of the (i - 1)-th envelope respectively. Chain size is the number of envelopes in the chain.
Peter wants to make the chain of the maximum size from the envelopes he has, the chain should be such, that he'll be able to put a card into it. The card fits into the chain if its width and height is lower than the width and the height of the smallest envelope in the chain respectively. It's forbidden to turn the card and the envelopes.
Peter has very many envelopes and very little time, this hard task is entrusted to you.
Input
The first line contains integers n, w, h (1 β€ n β€ 5000, 1 β€ w, h β€ 106) β amount of envelopes Peter has, the card width and height respectively. Then there follow n lines, each of them contains two integer numbers wi and hi β width and height of the i-th envelope (1 β€ wi, hi β€ 106).
Output
In the first line print the maximum chain size. In the second line print the numbers of the envelopes (separated by space), forming the required chain, starting with the number of the smallest envelope. Remember, please, that the card should fit into the smallest envelope. If the chain of maximum size is not unique, print any of the answers.
If the card does not fit into any of the envelopes, print number 0 in the single line.
Examples
Input
2 1 1
2 2
2 2
Output
1
1
Input
3 3 3
5 4
12 11
9 8
Output
3
1 3 2 | instruction | 0 | 96,527 | 14 | 193,054 |
Tags: dp, sortings
Correct Solution:
```
n,w,h=map(int,input().split())
a=[]
for i in range(n):
x,y=map(int,input().split())
if x>w and y>h:
a.append([x,y,i+1])
r=[1]*(len(a))
p=[0]*(n+1)
ans=0
a.sort()
for j in range(len(a)):
for i in range(j):
if a[j][0]>a[i][0] and a[j][1]>a[i][1]:
if r[j]<r[i]+1:
r[j]=r[i]+1
p[a[j][2]]=a[i][2]
if r[j]>ans:
ans =r[j]
q=a[j][2]
c=[]
if len(a)!=0:
while (q != 0):
c.append(q)
q = p[q]
c.reverse()
print(ans)
print(*c)
``` | output | 1 | 96,527 | 14 | 193,055 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Peter decided to wish happy birthday to his friend from Australia and send him a card. To make his present more mysterious, he decided to make a chain. Chain here is such a sequence of envelopes A = {a1, a2, ..., an}, where the width and the height of the i-th envelope is strictly higher than the width and the height of the (i - 1)-th envelope respectively. Chain size is the number of envelopes in the chain.
Peter wants to make the chain of the maximum size from the envelopes he has, the chain should be such, that he'll be able to put a card into it. The card fits into the chain if its width and height is lower than the width and the height of the smallest envelope in the chain respectively. It's forbidden to turn the card and the envelopes.
Peter has very many envelopes and very little time, this hard task is entrusted to you.
Input
The first line contains integers n, w, h (1 β€ n β€ 5000, 1 β€ w, h β€ 106) β amount of envelopes Peter has, the card width and height respectively. Then there follow n lines, each of them contains two integer numbers wi and hi β width and height of the i-th envelope (1 β€ wi, hi β€ 106).
Output
In the first line print the maximum chain size. In the second line print the numbers of the envelopes (separated by space), forming the required chain, starting with the number of the smallest envelope. Remember, please, that the card should fit into the smallest envelope. If the chain of maximum size is not unique, print any of the answers.
If the card does not fit into any of the envelopes, print number 0 in the single line.
Examples
Input
2 1 1
2 2
2 2
Output
1
1
Input
3 3 3
5 4
12 11
9 8
Output
3
1 3 2 | instruction | 0 | 96,528 | 14 | 193,056 |
Tags: dp, sortings
Correct Solution:
```
[n, W, H] = [int(a) for a in input().split(' ')]
arr = []
for i in range(n):
[w, h] = [int(a) for a in input().split(' ')]
arr.append((w, h, i, 0, 0))
arr.sort()
arr.append((10000000,10000000,n, 0, 0))
cnt = 0
for i in range(n + 1):
(w,h,x,a,pre) = arr[i]
a = 0
pre = -1
if W < w and H < h:
a = 1
cnt1 = 0
for j in arr:
if cnt == cnt1: break
(w1,h1,x0,a0,t) = j
if a0 > 0 and a < a0 + 1 and w1 < w and h1 < h:
a = a0 + 1
pre = cnt1
cnt1+=1
#print(a)
cnt+=1
arr[i] = (w,h,x,a,pre)
print (arr[-1][3] - 1)
idx = len(arr) - 1
l = []
for i in range(arr[-1][3] - 1):
idx = arr[idx][4]
l.append(str(arr[idx][2] + 1))
l.reverse()
print(' '.join(l))
``` | output | 1 | 96,528 | 14 | 193,057 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Peter decided to wish happy birthday to his friend from Australia and send him a card. To make his present more mysterious, he decided to make a chain. Chain here is such a sequence of envelopes A = {a1, a2, ..., an}, where the width and the height of the i-th envelope is strictly higher than the width and the height of the (i - 1)-th envelope respectively. Chain size is the number of envelopes in the chain.
Peter wants to make the chain of the maximum size from the envelopes he has, the chain should be such, that he'll be able to put a card into it. The card fits into the chain if its width and height is lower than the width and the height of the smallest envelope in the chain respectively. It's forbidden to turn the card and the envelopes.
Peter has very many envelopes and very little time, this hard task is entrusted to you.
Input
The first line contains integers n, w, h (1 β€ n β€ 5000, 1 β€ w, h β€ 106) β amount of envelopes Peter has, the card width and height respectively. Then there follow n lines, each of them contains two integer numbers wi and hi β width and height of the i-th envelope (1 β€ wi, hi β€ 106).
Output
In the first line print the maximum chain size. In the second line print the numbers of the envelopes (separated by space), forming the required chain, starting with the number of the smallest envelope. Remember, please, that the card should fit into the smallest envelope. If the chain of maximum size is not unique, print any of the answers.
If the card does not fit into any of the envelopes, print number 0 in the single line.
Examples
Input
2 1 1
2 2
2 2
Output
1
1
Input
3 3 3
5 4
12 11
9 8
Output
3
1 3 2 | instruction | 0 | 96,529 | 14 | 193,058 |
Tags: dp, sortings
Correct Solution:
```
n,w,h=map(int,input().split())
A=[]
for i in range(n):
wi,hi=map(int,input().split())
if wi > w and hi > h:
A.append((wi,hi,i+1))
A.sort()
n=len(A)
Length=[(10000000,-1)]*(n+1)
Length[0]=(0,-1)
Before=[-1]*5000
def bs(h):
beg,last=0,n
while 1:
mid=(last+beg)//2
if beg+1>=last:
if Length[last][0]<h:
return last
else:
return beg
if Length[mid][0]<h and Length[mid+1][0]>=h:
return mid
elif Length[mid][0]>h:
last=mid-1
else:
beg=mid
i=0
while i<n:
start=i
last=start+1
while last<n and A[last][0]==A[start][0]:
last+=1
for k in range(last-1,start-1,-1):
h=A[k][1]
Id=bs(h)
if Length[Id+1][0]>h and Length[Id][0]<h:
Length[Id+1]=(h,k)
Before[k]=Length[Id][1]
i=last
Max=0
iMax=-1
for k in range(n,-1,-1):
if Length[k][1]!=-1:
Max = k
iMax=Length[k][1]
break
print(Max)
R=[-1]*Max
while iMax!=-1:
R[Max-1]=A[iMax][2]
Max-=1
iMax=Before[iMax]
for i in R:
print(i,end=' ')
print()
``` | output | 1 | 96,529 | 14 | 193,059 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Peter decided to wish happy birthday to his friend from Australia and send him a card. To make his present more mysterious, he decided to make a chain. Chain here is such a sequence of envelopes A = {a1, a2, ..., an}, where the width and the height of the i-th envelope is strictly higher than the width and the height of the (i - 1)-th envelope respectively. Chain size is the number of envelopes in the chain.
Peter wants to make the chain of the maximum size from the envelopes he has, the chain should be such, that he'll be able to put a card into it. The card fits into the chain if its width and height is lower than the width and the height of the smallest envelope in the chain respectively. It's forbidden to turn the card and the envelopes.
Peter has very many envelopes and very little time, this hard task is entrusted to you.
Input
The first line contains integers n, w, h (1 β€ n β€ 5000, 1 β€ w, h β€ 106) β amount of envelopes Peter has, the card width and height respectively. Then there follow n lines, each of them contains two integer numbers wi and hi β width and height of the i-th envelope (1 β€ wi, hi β€ 106).
Output
In the first line print the maximum chain size. In the second line print the numbers of the envelopes (separated by space), forming the required chain, starting with the number of the smallest envelope. Remember, please, that the card should fit into the smallest envelope. If the chain of maximum size is not unique, print any of the answers.
If the card does not fit into any of the envelopes, print number 0 in the single line.
Examples
Input
2 1 1
2 2
2 2
Output
1
1
Input
3 3 3
5 4
12 11
9 8
Output
3
1 3 2 | instruction | 0 | 96,530 | 14 | 193,060 |
Tags: dp, sortings
Correct Solution:
```
def contains(a, b):
if a[0] > b[0] and a[1] > b[1]:
return True
return False
n, w, h = map(int, input().split(" "))
postcard = (w, h)
envelopes = []
for _ in range(n):
(w, h) = map(int, input().split(" "))
envelopes += [(w, h)]
# In increasing width and on ties, decreasing height
eh = sorted(enumerate(envelopes), key=lambda p: p[1])
envelopes = [e[1] for e in eh]
indices = [e[0]+1 for e in eh]
chain = [-1] * n
max_envelopes = [0]*n
for i, e1 in enumerate(envelopes):
if not contains(e1, postcard):
continue
for j, e2 in enumerate(envelopes[:i]):
if contains(e1, e2) and max_envelopes[i] < max_envelopes[j]:
max_envelopes[i] = max_envelopes[j]
chain[i] = j
max_envelopes[i] += 1
max_index, max_value = max(enumerate(max_envelopes), key=lambda p: p[1])
print(max_value)
i = max_index
if max_value > 0:
out = [indices[i]]
while chain[i] != -1:
out += [indices[chain[i]]]
i = chain[i]
out.reverse()
print(" ".join(map(str, out)))
``` | output | 1 | 96,530 | 14 | 193,061 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Peter decided to wish happy birthday to his friend from Australia and send him a card. To make his present more mysterious, he decided to make a chain. Chain here is such a sequence of envelopes A = {a1, a2, ..., an}, where the width and the height of the i-th envelope is strictly higher than the width and the height of the (i - 1)-th envelope respectively. Chain size is the number of envelopes in the chain.
Peter wants to make the chain of the maximum size from the envelopes he has, the chain should be such, that he'll be able to put a card into it. The card fits into the chain if its width and height is lower than the width and the height of the smallest envelope in the chain respectively. It's forbidden to turn the card and the envelopes.
Peter has very many envelopes and very little time, this hard task is entrusted to you.
Input
The first line contains integers n, w, h (1 β€ n β€ 5000, 1 β€ w, h β€ 106) β amount of envelopes Peter has, the card width and height respectively. Then there follow n lines, each of them contains two integer numbers wi and hi β width and height of the i-th envelope (1 β€ wi, hi β€ 106).
Output
In the first line print the maximum chain size. In the second line print the numbers of the envelopes (separated by space), forming the required chain, starting with the number of the smallest envelope. Remember, please, that the card should fit into the smallest envelope. If the chain of maximum size is not unique, print any of the answers.
If the card does not fit into any of the envelopes, print number 0 in the single line.
Examples
Input
2 1 1
2 2
2 2
Output
1
1
Input
3 3 3
5 4
12 11
9 8
Output
3
1 3 2 | instruction | 0 | 96,531 | 14 | 193,062 |
Tags: dp, sortings
Correct Solution:
```
from sys import stdin,stdout
import sys
from bisect import bisect_left,bisect_right
import heapq
# stdin = open("input.txt", "r");
# stdout = open("output.txt", "w");
n,w,h=stdin.readline().strip().split(' ')
n,w,h=int(n),int(w),int(h)
arr=[]
for i in range(n):
wi,hi=stdin.readline().strip().split(' ')
wi=int(wi);hi=int(hi)
if wi>w and hi>h:
arr.append((wi,hi,i))
n=len(arr)
if n==0:
stdout.write("0\n")
else:
arr=sorted(arr,key= lambda e: (e[1]))
#print(arr)
lis=[1 for i in range(n)]
lisselect=[None for i in range(n)]
for i in range(n):
for j in range(i):
if arr[j][0]<arr[i][0] and arr[j][1]!=arr[i][1] and lis[j]+1>lis[i]:
lis[i]=lis[j]+1
lisselect[i]=j
# print(lis)
# print(lisselect)
slis=max(lis)
sel=None
for i in range(len(lis)):
if lis[i]==slis:
sel=i
stdout.write(str(slis)+"\n")
tarr=[]
while sel!=None:
tarr.append(arr[sel][2]+1)
sel=lisselect[sel]
tarr=tarr[::-1]
for i in tarr:
stdout.write(str(i)+" ")
``` | output | 1 | 96,531 | 14 | 193,063 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Peter decided to wish happy birthday to his friend from Australia and send him a card. To make his present more mysterious, he decided to make a chain. Chain here is such a sequence of envelopes A = {a1, a2, ..., an}, where the width and the height of the i-th envelope is strictly higher than the width and the height of the (i - 1)-th envelope respectively. Chain size is the number of envelopes in the chain.
Peter wants to make the chain of the maximum size from the envelopes he has, the chain should be such, that he'll be able to put a card into it. The card fits into the chain if its width and height is lower than the width and the height of the smallest envelope in the chain respectively. It's forbidden to turn the card and the envelopes.
Peter has very many envelopes and very little time, this hard task is entrusted to you.
Input
The first line contains integers n, w, h (1 β€ n β€ 5000, 1 β€ w, h β€ 106) β amount of envelopes Peter has, the card width and height respectively. Then there follow n lines, each of them contains two integer numbers wi and hi β width and height of the i-th envelope (1 β€ wi, hi β€ 106).
Output
In the first line print the maximum chain size. In the second line print the numbers of the envelopes (separated by space), forming the required chain, starting with the number of the smallest envelope. Remember, please, that the card should fit into the smallest envelope. If the chain of maximum size is not unique, print any of the answers.
If the card does not fit into any of the envelopes, print number 0 in the single line.
Examples
Input
2 1 1
2 2
2 2
Output
1
1
Input
3 3 3
5 4
12 11
9 8
Output
3
1 3 2 | instruction | 0 | 96,532 | 14 | 193,064 |
Tags: dp, sortings
Correct Solution:
```
n, w, h = map(int, input().split())
arr = []
for i in range(0, n):
x, y = map(int, input().split())
if x > w and y > h:
arr.append((x, y, i))
arr.sort(key=lambda x: (x[0], -x[1]))
# print(arr)
n = len(arr)
dp = [(1, -1) for i in range(0, n)]
# dp[0] = (1, -1)
res = 0
end = 0
for i in range(0, n):
x, y, _ = arr[i]
for j in range(0, i):
if arr[j][0] < x and arr[j][1] < y and dp[j][0] + 1 > dp[i][0]:
dp[i] = (dp[j][0] + 1, j)
if dp[i][0] > res:
res = dp[i][0]
end = i
# left, right = 0, i - 1
# while left < right - 1:
# mid = int((right + left) / 2)
# if arr[mid][0] < x and arr[mid][1] < y:
# left = mid
# else:
# right = mid
# if arr[right][0] < x and arr[right][1] < y:
# dp[i] = (dp[right][0] + 1, right)
# elif arr[left][0] < x and arr[left][1] < y:
# dp[i] = (dp[left][0] + 1, left)
# else:
# dp[i] = (1, -1)
# if dp[i][0] > res:
# res = dp[i][0]
# end = i
# print(dp[i])
if res == 0:
print(0)
else:
print(res)
chain = []
while end >= 0:
chain.insert(0, arr[end][2] + 1)
end = dp[end][1]
# print(end)
print(" ".join(map(str, chain)))
``` | output | 1 | 96,532 | 14 | 193,065 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Peter decided to wish happy birthday to his friend from Australia and send him a card. To make his present more mysterious, he decided to make a chain. Chain here is such a sequence of envelopes A = {a1, a2, ..., an}, where the width and the height of the i-th envelope is strictly higher than the width and the height of the (i - 1)-th envelope respectively. Chain size is the number of envelopes in the chain.
Peter wants to make the chain of the maximum size from the envelopes he has, the chain should be such, that he'll be able to put a card into it. The card fits into the chain if its width and height is lower than the width and the height of the smallest envelope in the chain respectively. It's forbidden to turn the card and the envelopes.
Peter has very many envelopes and very little time, this hard task is entrusted to you.
Input
The first line contains integers n, w, h (1 β€ n β€ 5000, 1 β€ w, h β€ 106) β amount of envelopes Peter has, the card width and height respectively. Then there follow n lines, each of them contains two integer numbers wi and hi β width and height of the i-th envelope (1 β€ wi, hi β€ 106).
Output
In the first line print the maximum chain size. In the second line print the numbers of the envelopes (separated by space), forming the required chain, starting with the number of the smallest envelope. Remember, please, that the card should fit into the smallest envelope. If the chain of maximum size is not unique, print any of the answers.
If the card does not fit into any of the envelopes, print number 0 in the single line.
Examples
Input
2 1 1
2 2
2 2
Output
1
1
Input
3 3 3
5 4
12 11
9 8
Output
3
1 3 2 | instruction | 0 | 96,533 | 14 | 193,066 |
Tags: dp, sortings
Correct Solution:
```
def solution(a):
if len(a) <= 1:
return a
# find longest subsequence, don't worry about indexing right now, just get the actual set
dp = [1] * len(a)
back = {}
maxval = 0
for j in range(len(a)):
for i in range(j):
if a[i][0] < a[j][0] and a[i][1] < a[j][1]:
if dp[i] + 1 > dp[j]:
dp[j] = dp[i] + 1
back[j] = i
maxval = max(maxval, dp[j])
j = 0
for i in range(len(dp)):
if dp[i] == maxval:
j = i
break
# find the place where it have the
res = []
while j in back:
res.append(a[j])
j = back[j]
res.append(a[j])
return res[::-1]
# width and height of ith is larger than i - 1
if __name__ == '__main__':
# amount, width, height
N, W, H = input().split()
cnt = 1
# remember the coordinate, we also use filter to clean up the array
# such that any thing less than base w, h is not in the array
dic = {}
res = []
for _ in range(int(N)):
w, h = input().split()
if int(W) < int(w) and int(H) < int(h):
res.append([int(w), int(h)])
dic[(int(w), int(h))] = cnt
cnt += 1
res = sorted(res, key=lambda x: (x[0], x[1]))
li = solution(res)
if not li:
print(0)
else:
print(len(li))
for x, y in li:
print(dic[(x, y)], end=" ")
# first, print max chain size, second, print num of envelopes
``` | output | 1 | 96,533 | 14 | 193,067 |
Provide tags and a correct Python 2 solution for this coding contest problem.
Peter decided to wish happy birthday to his friend from Australia and send him a card. To make his present more mysterious, he decided to make a chain. Chain here is such a sequence of envelopes A = {a1, a2, ..., an}, where the width and the height of the i-th envelope is strictly higher than the width and the height of the (i - 1)-th envelope respectively. Chain size is the number of envelopes in the chain.
Peter wants to make the chain of the maximum size from the envelopes he has, the chain should be such, that he'll be able to put a card into it. The card fits into the chain if its width and height is lower than the width and the height of the smallest envelope in the chain respectively. It's forbidden to turn the card and the envelopes.
Peter has very many envelopes and very little time, this hard task is entrusted to you.
Input
The first line contains integers n, w, h (1 β€ n β€ 5000, 1 β€ w, h β€ 106) β amount of envelopes Peter has, the card width and height respectively. Then there follow n lines, each of them contains two integer numbers wi and hi β width and height of the i-th envelope (1 β€ wi, hi β€ 106).
Output
In the first line print the maximum chain size. In the second line print the numbers of the envelopes (separated by space), forming the required chain, starting with the number of the smallest envelope. Remember, please, that the card should fit into the smallest envelope. If the chain of maximum size is not unique, print any of the answers.
If the card does not fit into any of the envelopes, print number 0 in the single line.
Examples
Input
2 1 1
2 2
2 2
Output
1
1
Input
3 3 3
5 4
12 11
9 8
Output
3
1 3 2 | instruction | 0 | 96,534 | 14 | 193,068 |
Tags: dp, sortings
Correct Solution:
```
from sys import stdin, stdout
from collections import Counter, defaultdict
from itertools import permutations, combinations
raw_input = stdin.readline
pr = stdout.write
def in_num():
return int(raw_input())
def in_arr():
return map(int,raw_input().split())
def pr_num(n):
stdout.write(str(n)+'\n')
def pr_arr(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+
n,w,h=in_arr()
arr=[]
for i in range(n):
arr.append(in_arr()+[i+1])
arr.sort()
dp=[1]*n
d=[[arr[i][-1]] for i in range(n)]
for i in range(n-2,-1,-1):
val=[]
for j in range(i+1,n):
if arr[i][0]<arr[j][0] and arr[i][1]<arr[j][1]:
if dp[i]<dp[j]+1:
dp[i]=dp[j]+1
val=d[j]
d[i]+=val
ans=0
ind=-1
for i in range(n):
if arr[i][0]>w and arr[i][1]>h and dp[i]>ans:
ans=dp[i]
ind=i
pr_num(ans)
if ans:
pr_arr(d[ind])
``` | output | 1 | 96,534 | 14 | 193,069 |
Provide tags and a correct Python 3 solution for this coding contest problem.
According to rules of the Berland fashion, a jacket should be fastened by all the buttons except only one, but not necessarily it should be the last one. Also if the jacket has only one button, it should be fastened, so the jacket will not swinging open.
You are given a jacket with n buttons. Determine if it is fastened in a right way.
Input
The first line contains integer n (1 β€ n β€ 1000) β the number of buttons on the jacket.
The second line contains n integers ai (0 β€ ai β€ 1). The number ai = 0 if the i-th button is not fastened. Otherwise ai = 1.
Output
In the only line print the word "YES" if the jacket is fastened in a right way. Otherwise print the word "NO".
Examples
Input
3
1 0 1
Output
YES
Input
3
1 0 0
Output
NO | instruction | 0 | 96,615 | 14 | 193,230 |
Tags: implementation
Correct Solution:
```
test= int(input())
# while test> 0:
count= input().split().count("0")
if count==1 and test==1: print("NO")
elif count==0 and test==1 : print("YES")
elif count==1 : print("YES")
else: print("NO")
``` | output | 1 | 96,615 | 14 | 193,231 |
Provide tags and a correct Python 3 solution for this coding contest problem.
According to rules of the Berland fashion, a jacket should be fastened by all the buttons except only one, but not necessarily it should be the last one. Also if the jacket has only one button, it should be fastened, so the jacket will not swinging open.
You are given a jacket with n buttons. Determine if it is fastened in a right way.
Input
The first line contains integer n (1 β€ n β€ 1000) β the number of buttons on the jacket.
The second line contains n integers ai (0 β€ ai β€ 1). The number ai = 0 if the i-th button is not fastened. Otherwise ai = 1.
Output
In the only line print the word "YES" if the jacket is fastened in a right way. Otherwise print the word "NO".
Examples
Input
3
1 0 1
Output
YES
Input
3
1 0 0
Output
NO | instruction | 0 | 96,616 | 14 | 193,232 |
Tags: implementation
Correct Solution:
```
if __name__ == "__main__":
n, x = int(input()), [int(i) for i in input().split()]
print('NO' if (n == 1 and x[0] == 0) or (n > 1 and sum(x) != n-1) else 'YES')
``` | output | 1 | 96,616 | 14 | 193,233 |
Provide tags and a correct Python 3 solution for this coding contest problem.
According to rules of the Berland fashion, a jacket should be fastened by all the buttons except only one, but not necessarily it should be the last one. Also if the jacket has only one button, it should be fastened, so the jacket will not swinging open.
You are given a jacket with n buttons. Determine if it is fastened in a right way.
Input
The first line contains integer n (1 β€ n β€ 1000) β the number of buttons on the jacket.
The second line contains n integers ai (0 β€ ai β€ 1). The number ai = 0 if the i-th button is not fastened. Otherwise ai = 1.
Output
In the only line print the word "YES" if the jacket is fastened in a right way. Otherwise print the word "NO".
Examples
Input
3
1 0 1
Output
YES
Input
3
1 0 0
Output
NO | instruction | 0 | 96,617 | 14 | 193,234 |
Tags: implementation
Correct Solution:
```
n=int(input())
li=list(map(int,input().split()))
flag=0
if n==1 and li[0]==0:
flag=1
elif n==1 and li[0]==1:
flag=0
else:
k=li.count(1)
if n-k>1 or n-k==0:
flag=1
if flag==1:
print("NO")
else:
print("YES")
``` | output | 1 | 96,617 | 14 | 193,235 |
Provide tags and a correct Python 3 solution for this coding contest problem.
According to rules of the Berland fashion, a jacket should be fastened by all the buttons except only one, but not necessarily it should be the last one. Also if the jacket has only one button, it should be fastened, so the jacket will not swinging open.
You are given a jacket with n buttons. Determine if it is fastened in a right way.
Input
The first line contains integer n (1 β€ n β€ 1000) β the number of buttons on the jacket.
The second line contains n integers ai (0 β€ ai β€ 1). The number ai = 0 if the i-th button is not fastened. Otherwise ai = 1.
Output
In the only line print the word "YES" if the jacket is fastened in a right way. Otherwise print the word "NO".
Examples
Input
3
1 0 1
Output
YES
Input
3
1 0 0
Output
NO | instruction | 0 | 96,618 | 14 | 193,236 |
Tags: implementation
Correct Solution:
```
# n = 1
# list_ = [1, 0, 1]
# list_ = [1, 0, 0]
# list_ = [1, 1, 0]
# list_ = [1, 0, 1]
# list_ = [0]
# list_ = [1, 0, 0]
n = int(input())
list_ = [int(x) for x in input().split()]
# n = len(list_)
count = 0
if (n == 1 and list_[0] == 1):
print("YES")
elif (n == 1 and list_[0] == 0):
print("NO")
else:
for i in range(n):
if (list_[i] == 0):
count = count + 1
if (count == 1):
print("YES")
else:
print("NO")
### no but say yes
``` | output | 1 | 96,618 | 14 | 193,237 |
Provide tags and a correct Python 3 solution for this coding contest problem.
According to rules of the Berland fashion, a jacket should be fastened by all the buttons except only one, but not necessarily it should be the last one. Also if the jacket has only one button, it should be fastened, so the jacket will not swinging open.
You are given a jacket with n buttons. Determine if it is fastened in a right way.
Input
The first line contains integer n (1 β€ n β€ 1000) β the number of buttons on the jacket.
The second line contains n integers ai (0 β€ ai β€ 1). The number ai = 0 if the i-th button is not fastened. Otherwise ai = 1.
Output
In the only line print the word "YES" if the jacket is fastened in a right way. Otherwise print the word "NO".
Examples
Input
3
1 0 1
Output
YES
Input
3
1 0 0
Output
NO | instruction | 0 | 96,619 | 14 | 193,238 |
Tags: implementation
Correct Solution:
```
n=int(input())
l=list(map(int,input().split()))
if l.count(0)==1 and len(l)>1 or len(l)==1 and l[0]==1:
print("YES")
else:
print("NO")
``` | output | 1 | 96,619 | 14 | 193,239 |
Provide tags and a correct Python 3 solution for this coding contest problem.
According to rules of the Berland fashion, a jacket should be fastened by all the buttons except only one, but not necessarily it should be the last one. Also if the jacket has only one button, it should be fastened, so the jacket will not swinging open.
You are given a jacket with n buttons. Determine if it is fastened in a right way.
Input
The first line contains integer n (1 β€ n β€ 1000) β the number of buttons on the jacket.
The second line contains n integers ai (0 β€ ai β€ 1). The number ai = 0 if the i-th button is not fastened. Otherwise ai = 1.
Output
In the only line print the word "YES" if the jacket is fastened in a right way. Otherwise print the word "NO".
Examples
Input
3
1 0 1
Output
YES
Input
3
1 0 0
Output
NO | instruction | 0 | 96,620 | 14 | 193,240 |
Tags: implementation
Correct Solution:
```
# Name : Sachdev Hitesh
# College : GLSICA
user=int(input())
s=list(input().split(" "))
c=0
if user==1 and int(s[0])==1:
print("YES")
elif user==1 and int(s[0])==0:
print("NO")
else:
for i in s:
if int(i)==0:
c+=1
if c==1:
print("YES")
else:
print("NO")
``` | output | 1 | 96,620 | 14 | 193,241 |
Provide tags and a correct Python 3 solution for this coding contest problem.
According to rules of the Berland fashion, a jacket should be fastened by all the buttons except only one, but not necessarily it should be the last one. Also if the jacket has only one button, it should be fastened, so the jacket will not swinging open.
You are given a jacket with n buttons. Determine if it is fastened in a right way.
Input
The first line contains integer n (1 β€ n β€ 1000) β the number of buttons on the jacket.
The second line contains n integers ai (0 β€ ai β€ 1). The number ai = 0 if the i-th button is not fastened. Otherwise ai = 1.
Output
In the only line print the word "YES" if the jacket is fastened in a right way. Otherwise print the word "NO".
Examples
Input
3
1 0 1
Output
YES
Input
3
1 0 0
Output
NO | instruction | 0 | 96,621 | 14 | 193,242 |
Tags: implementation
Correct Solution:
```
if __name__ == "__main__":
n, x = int(input()), [int(i) for i in input().split()]
if n == 1:
print('YES' if x[0] == 1 else 'NO')
elif sum(x) == n - 1:
print('YES')
else:
print('NO')
``` | output | 1 | 96,621 | 14 | 193,243 |
Provide tags and a correct Python 3 solution for this coding contest problem.
According to rules of the Berland fashion, a jacket should be fastened by all the buttons except only one, but not necessarily it should be the last one. Also if the jacket has only one button, it should be fastened, so the jacket will not swinging open.
You are given a jacket with n buttons. Determine if it is fastened in a right way.
Input
The first line contains integer n (1 β€ n β€ 1000) β the number of buttons on the jacket.
The second line contains n integers ai (0 β€ ai β€ 1). The number ai = 0 if the i-th button is not fastened. Otherwise ai = 1.
Output
In the only line print the word "YES" if the jacket is fastened in a right way. Otherwise print the word "NO".
Examples
Input
3
1 0 1
Output
YES
Input
3
1 0 0
Output
NO | instruction | 0 | 96,622 | 14 | 193,244 |
Tags: implementation
Correct Solution:
```
n = int(input())
a = list(map(int, input().split()))
if (n == 1):
if (a[0] == 1):
print ("YES")
else:
print ("NO")
exit()
count = 0
result = 1
for i in range(n):
if a[i] == 0:
count += 1
if count == 1:
print("YES")
else:
print("NO")
``` | output | 1 | 96,622 | 14 | 193,245 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
According to rules of the Berland fashion, a jacket should be fastened by all the buttons except only one, but not necessarily it should be the last one. Also if the jacket has only one button, it should be fastened, so the jacket will not swinging open.
You are given a jacket with n buttons. Determine if it is fastened in a right way.
Input
The first line contains integer n (1 β€ n β€ 1000) β the number of buttons on the jacket.
The second line contains n integers ai (0 β€ ai β€ 1). The number ai = 0 if the i-th button is not fastened. Otherwise ai = 1.
Output
In the only line print the word "YES" if the jacket is fastened in a right way. Otherwise print the word "NO".
Examples
Input
3
1 0 1
Output
YES
Input
3
1 0 0
Output
NO
Submitted Solution:
```
n = int(input())
A = list(map(int, input().split()))
if(n == 1):
if(A[0] == 1):
print("YES")
else:
print("NO")
else:
if(A[0] == 1 and A[-1]==1):
print("YES")
else:
print("NO")
``` | instruction | 0 | 96,628 | 14 | 193,256 |
No | output | 1 | 96,628 | 14 | 193,257 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently n students from city S moved to city P to attend a programming camp.
They moved there by train. In the evening, all students in the train decided that they want to drink some tea. Of course, no two people can use the same teapot simultaneously, so the students had to form a queue to get their tea.
i-th student comes to the end of the queue at the beginning of li-th second. If there are multiple students coming to the queue in the same moment, then the student with greater index comes after the student with lesser index. Students in the queue behave as follows: if there is nobody in the queue before the student, then he uses the teapot for exactly one second and leaves the queue with his tea; otherwise the student waits for the people before him to get their tea. If at the beginning of ri-th second student i still cannot get his tea (there is someone before him in the queue), then he leaves the queue without getting any tea.
For each student determine the second he will use the teapot and get his tea (if he actually gets it).
Input
The first line contains one integer t β the number of test cases to solve (1 β€ t β€ 1000).
Then t test cases follow. The first line of each test case contains one integer n (1 β€ n β€ 1000) β the number of students.
Then n lines follow. Each line contains two integer li, ri (1 β€ li β€ ri β€ 5000) β the second i-th student comes to the end of the queue, and the second he leaves the queue if he still cannot get his tea.
It is guaranteed that for every <image> condition li - 1 β€ li holds.
The sum of n over all test cases doesn't exceed 1000.
Note that in hacks you have to set t = 1.
Output
For each test case print n integers. i-th of them must be equal to the second when i-th student gets his tea, or 0 if he leaves without tea.
Example
Input
2
2
1 3
1 4
3
1 5
1 1
2 3
Output
1 2
1 0 2
Note
The example contains 2 tests:
1. During 1-st second, students 1 and 2 come to the queue, and student 1 gets his tea. Student 2 gets his tea during 2-nd second.
2. During 1-st second, students 1 and 2 come to the queue, student 1 gets his tea, and student 2 leaves without tea. During 2-nd second, student 3 comes and gets his tea. | instruction | 0 | 96,695 | 14 | 193,390 |
Tags: implementation
Correct Solution:
```
for _ in range(int(input())):
n=int(input())
queue=[]
for i in range(n):
l,r=map(int,input().split())
queue.append([l,r])
ans=[]
curr=0
for i in range(n):
if curr<=queue[i][1]:
ans.append(max(queue[i][0],curr))
curr=max(queue[i][0],curr)+1
else:
ans.append(0)
print(*ans)
``` | output | 1 | 96,695 | 14 | 193,391 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently n students from city S moved to city P to attend a programming camp.
They moved there by train. In the evening, all students in the train decided that they want to drink some tea. Of course, no two people can use the same teapot simultaneously, so the students had to form a queue to get their tea.
i-th student comes to the end of the queue at the beginning of li-th second. If there are multiple students coming to the queue in the same moment, then the student with greater index comes after the student with lesser index. Students in the queue behave as follows: if there is nobody in the queue before the student, then he uses the teapot for exactly one second and leaves the queue with his tea; otherwise the student waits for the people before him to get their tea. If at the beginning of ri-th second student i still cannot get his tea (there is someone before him in the queue), then he leaves the queue without getting any tea.
For each student determine the second he will use the teapot and get his tea (if he actually gets it).
Input
The first line contains one integer t β the number of test cases to solve (1 β€ t β€ 1000).
Then t test cases follow. The first line of each test case contains one integer n (1 β€ n β€ 1000) β the number of students.
Then n lines follow. Each line contains two integer li, ri (1 β€ li β€ ri β€ 5000) β the second i-th student comes to the end of the queue, and the second he leaves the queue if he still cannot get his tea.
It is guaranteed that for every <image> condition li - 1 β€ li holds.
The sum of n over all test cases doesn't exceed 1000.
Note that in hacks you have to set t = 1.
Output
For each test case print n integers. i-th of them must be equal to the second when i-th student gets his tea, or 0 if he leaves without tea.
Example
Input
2
2
1 3
1 4
3
1 5
1 1
2 3
Output
1 2
1 0 2
Note
The example contains 2 tests:
1. During 1-st second, students 1 and 2 come to the queue, and student 1 gets his tea. Student 2 gets his tea during 2-nd second.
2. During 1-st second, students 1 and 2 come to the queue, student 1 gets his tea, and student 2 leaves without tea. During 2-nd second, student 3 comes and gets his tea. | instruction | 0 | 96,696 | 14 | 193,392 |
Tags: implementation
Correct Solution:
```
a=int(input())
x=[]
for i in range(a):
n=int(input())
z=[]
y=[]
for j in range(n):
l,k=map(int,input().split())
y=[l,k]
z.append(y)
x.append(z)
v=[]
for i in range(a):
t=0
b=x[i]
w=[]
for j in b:
if t<=j[0]:
t=j[0]+1
w.append(j[0])
elif j[0]<t<=j[1]:
w.append(t)
t=t+1
else:
w.append(0)
v.append(w)
for i in v:
e=""
for j in i:
d=str(j)
e=e+d+" "
print(e)
``` | output | 1 | 96,696 | 14 | 193,393 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently n students from city S moved to city P to attend a programming camp.
They moved there by train. In the evening, all students in the train decided that they want to drink some tea. Of course, no two people can use the same teapot simultaneously, so the students had to form a queue to get their tea.
i-th student comes to the end of the queue at the beginning of li-th second. If there are multiple students coming to the queue in the same moment, then the student with greater index comes after the student with lesser index. Students in the queue behave as follows: if there is nobody in the queue before the student, then he uses the teapot for exactly one second and leaves the queue with his tea; otherwise the student waits for the people before him to get their tea. If at the beginning of ri-th second student i still cannot get his tea (there is someone before him in the queue), then he leaves the queue without getting any tea.
For each student determine the second he will use the teapot and get his tea (if he actually gets it).
Input
The first line contains one integer t β the number of test cases to solve (1 β€ t β€ 1000).
Then t test cases follow. The first line of each test case contains one integer n (1 β€ n β€ 1000) β the number of students.
Then n lines follow. Each line contains two integer li, ri (1 β€ li β€ ri β€ 5000) β the second i-th student comes to the end of the queue, and the second he leaves the queue if he still cannot get his tea.
It is guaranteed that for every <image> condition li - 1 β€ li holds.
The sum of n over all test cases doesn't exceed 1000.
Note that in hacks you have to set t = 1.
Output
For each test case print n integers. i-th of them must be equal to the second when i-th student gets his tea, or 0 if he leaves without tea.
Example
Input
2
2
1 3
1 4
3
1 5
1 1
2 3
Output
1 2
1 0 2
Note
The example contains 2 tests:
1. During 1-st second, students 1 and 2 come to the queue, and student 1 gets his tea. Student 2 gets his tea during 2-nd second.
2. During 1-st second, students 1 and 2 come to the queue, student 1 gets his tea, and student 2 leaves without tea. During 2-nd second, student 3 comes and gets his tea. | instruction | 0 | 96,697 | 14 | 193,394 |
Tags: implementation
Correct Solution:
```
t = int(input())
for _ in range(t):
n = int(input())
last = 0
ans = []
for i in range(n):
start, end = map(int,input().split())
if last < end:
last = max(last+1,start)
ans.append(last)
else:
ans.append(0)
print(*ans)
``` | output | 1 | 96,697 | 14 | 193,395 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently n students from city S moved to city P to attend a programming camp.
They moved there by train. In the evening, all students in the train decided that they want to drink some tea. Of course, no two people can use the same teapot simultaneously, so the students had to form a queue to get their tea.
i-th student comes to the end of the queue at the beginning of li-th second. If there are multiple students coming to the queue in the same moment, then the student with greater index comes after the student with lesser index. Students in the queue behave as follows: if there is nobody in the queue before the student, then he uses the teapot for exactly one second and leaves the queue with his tea; otherwise the student waits for the people before him to get their tea. If at the beginning of ri-th second student i still cannot get his tea (there is someone before him in the queue), then he leaves the queue without getting any tea.
For each student determine the second he will use the teapot and get his tea (if he actually gets it).
Input
The first line contains one integer t β the number of test cases to solve (1 β€ t β€ 1000).
Then t test cases follow. The first line of each test case contains one integer n (1 β€ n β€ 1000) β the number of students.
Then n lines follow. Each line contains two integer li, ri (1 β€ li β€ ri β€ 5000) β the second i-th student comes to the end of the queue, and the second he leaves the queue if he still cannot get his tea.
It is guaranteed that for every <image> condition li - 1 β€ li holds.
The sum of n over all test cases doesn't exceed 1000.
Note that in hacks you have to set t = 1.
Output
For each test case print n integers. i-th of them must be equal to the second when i-th student gets his tea, or 0 if he leaves without tea.
Example
Input
2
2
1 3
1 4
3
1 5
1 1
2 3
Output
1 2
1 0 2
Note
The example contains 2 tests:
1. During 1-st second, students 1 and 2 come to the queue, and student 1 gets his tea. Student 2 gets his tea during 2-nd second.
2. During 1-st second, students 1 and 2 come to the queue, student 1 gets his tea, and student 2 leaves without tea. During 2-nd second, student 3 comes and gets his tea. | instruction | 0 | 96,698 | 14 | 193,396 |
Tags: implementation
Correct Solution:
```
t = int(input())
for i in range(t):
n = int(input())
a, ans = [], []
for j in range(n):
x = list(map(int, input().split()))
a.append(x)
#print(a)
cur_sec = a[0][0]
for p in range(n):
if a[p][0] <= cur_sec <= a[p][1]:
ans.append(cur_sec)
cur_sec += 1
elif a[p][0] >= cur_sec:
ans.append(a[p][0])
cur_sec = a[p][0] + 1
else:
ans.append(0)
#cur_sec += 1
print(*ans)
``` | output | 1 | 96,698 | 14 | 193,397 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently n students from city S moved to city P to attend a programming camp.
They moved there by train. In the evening, all students in the train decided that they want to drink some tea. Of course, no two people can use the same teapot simultaneously, so the students had to form a queue to get their tea.
i-th student comes to the end of the queue at the beginning of li-th second. If there are multiple students coming to the queue in the same moment, then the student with greater index comes after the student with lesser index. Students in the queue behave as follows: if there is nobody in the queue before the student, then he uses the teapot for exactly one second and leaves the queue with his tea; otherwise the student waits for the people before him to get their tea. If at the beginning of ri-th second student i still cannot get his tea (there is someone before him in the queue), then he leaves the queue without getting any tea.
For each student determine the second he will use the teapot and get his tea (if he actually gets it).
Input
The first line contains one integer t β the number of test cases to solve (1 β€ t β€ 1000).
Then t test cases follow. The first line of each test case contains one integer n (1 β€ n β€ 1000) β the number of students.
Then n lines follow. Each line contains two integer li, ri (1 β€ li β€ ri β€ 5000) β the second i-th student comes to the end of the queue, and the second he leaves the queue if he still cannot get his tea.
It is guaranteed that for every <image> condition li - 1 β€ li holds.
The sum of n over all test cases doesn't exceed 1000.
Note that in hacks you have to set t = 1.
Output
For each test case print n integers. i-th of them must be equal to the second when i-th student gets his tea, or 0 if he leaves without tea.
Example
Input
2
2
1 3
1 4
3
1 5
1 1
2 3
Output
1 2
1 0 2
Note
The example contains 2 tests:
1. During 1-st second, students 1 and 2 come to the queue, and student 1 gets his tea. Student 2 gets his tea during 2-nd second.
2. During 1-st second, students 1 and 2 come to the queue, student 1 gets his tea, and student 2 leaves without tea. During 2-nd second, student 3 comes and gets his tea. | instruction | 0 | 96,699 | 14 | 193,398 |
Tags: implementation
Correct Solution:
```
for _ in range(int(input())):
n = int(input())
ar = []
for i in range(n):
x, y = map(int, input().split())
ar.append([x, i, y])
ar.sort()
ans = [0 for i in range(n)]
cur = 1
for i in range(n):
cur = max(cur, ar[i][0])
if(cur <= ar[i][2]):
ans[ar[i][1]] = cur
cur += 1
else:
ans[ar[i][1]] = 0
print(*ans)
``` | output | 1 | 96,699 | 14 | 193,399 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently n students from city S moved to city P to attend a programming camp.
They moved there by train. In the evening, all students in the train decided that they want to drink some tea. Of course, no two people can use the same teapot simultaneously, so the students had to form a queue to get their tea.
i-th student comes to the end of the queue at the beginning of li-th second. If there are multiple students coming to the queue in the same moment, then the student with greater index comes after the student with lesser index. Students in the queue behave as follows: if there is nobody in the queue before the student, then he uses the teapot for exactly one second and leaves the queue with his tea; otherwise the student waits for the people before him to get their tea. If at the beginning of ri-th second student i still cannot get his tea (there is someone before him in the queue), then he leaves the queue without getting any tea.
For each student determine the second he will use the teapot and get his tea (if he actually gets it).
Input
The first line contains one integer t β the number of test cases to solve (1 β€ t β€ 1000).
Then t test cases follow. The first line of each test case contains one integer n (1 β€ n β€ 1000) β the number of students.
Then n lines follow. Each line contains two integer li, ri (1 β€ li β€ ri β€ 5000) β the second i-th student comes to the end of the queue, and the second he leaves the queue if he still cannot get his tea.
It is guaranteed that for every <image> condition li - 1 β€ li holds.
The sum of n over all test cases doesn't exceed 1000.
Note that in hacks you have to set t = 1.
Output
For each test case print n integers. i-th of them must be equal to the second when i-th student gets his tea, or 0 if he leaves without tea.
Example
Input
2
2
1 3
1 4
3
1 5
1 1
2 3
Output
1 2
1 0 2
Note
The example contains 2 tests:
1. During 1-st second, students 1 and 2 come to the queue, and student 1 gets his tea. Student 2 gets his tea during 2-nd second.
2. During 1-st second, students 1 and 2 come to the queue, student 1 gets his tea, and student 2 leaves without tea. During 2-nd second, student 3 comes and gets his tea. | instruction | 0 | 96,700 | 14 | 193,400 |
Tags: implementation
Correct Solution:
```
## ar = list(map(int, input().strip().split(' ')))
t=int(input())
for i in range(t):
n=int(input())
l=[]
c=0
for j in range(n):
li,ri = map(int, input().strip().split(' '))
if j==0:
if li<=ri:
l.append(li)
c+=li
else:
l.append(0)
c=0
else:
if ri<=c:
l.append(0)
else:
c=max(c+1,li)
l.append(c)
for j in range(n):
print(l[j],end=" ")
print()
``` | output | 1 | 96,700 | 14 | 193,401 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently n students from city S moved to city P to attend a programming camp.
They moved there by train. In the evening, all students in the train decided that they want to drink some tea. Of course, no two people can use the same teapot simultaneously, so the students had to form a queue to get their tea.
i-th student comes to the end of the queue at the beginning of li-th second. If there are multiple students coming to the queue in the same moment, then the student with greater index comes after the student with lesser index. Students in the queue behave as follows: if there is nobody in the queue before the student, then he uses the teapot for exactly one second and leaves the queue with his tea; otherwise the student waits for the people before him to get their tea. If at the beginning of ri-th second student i still cannot get his tea (there is someone before him in the queue), then he leaves the queue without getting any tea.
For each student determine the second he will use the teapot and get his tea (if he actually gets it).
Input
The first line contains one integer t β the number of test cases to solve (1 β€ t β€ 1000).
Then t test cases follow. The first line of each test case contains one integer n (1 β€ n β€ 1000) β the number of students.
Then n lines follow. Each line contains two integer li, ri (1 β€ li β€ ri β€ 5000) β the second i-th student comes to the end of the queue, and the second he leaves the queue if he still cannot get his tea.
It is guaranteed that for every <image> condition li - 1 β€ li holds.
The sum of n over all test cases doesn't exceed 1000.
Note that in hacks you have to set t = 1.
Output
For each test case print n integers. i-th of them must be equal to the second when i-th student gets his tea, or 0 if he leaves without tea.
Example
Input
2
2
1 3
1 4
3
1 5
1 1
2 3
Output
1 2
1 0 2
Note
The example contains 2 tests:
1. During 1-st second, students 1 and 2 come to the queue, and student 1 gets his tea. Student 2 gets his tea during 2-nd second.
2. During 1-st second, students 1 and 2 come to the queue, student 1 gets his tea, and student 2 leaves without tea. During 2-nd second, student 3 comes and gets his tea. | instruction | 0 | 96,701 | 14 | 193,402 |
Tags: implementation
Correct Solution:
```
for repeat in range(int(input())):
studentsnum = int(input())
res = ""
laststudent = 0
for i in range(studentsnum):
inp = input().split(" ", 1)
arrival = int(inp[0])
departure = int(inp[1])
if arrival > laststudent:
laststudent = arrival
if departure < laststudent:
res = res + str(0) + " "
else:
res = res + str(laststudent) + " "
laststudent = laststudent + 1
print(res)
``` | output | 1 | 96,701 | 14 | 193,403 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently n students from city S moved to city P to attend a programming camp.
They moved there by train. In the evening, all students in the train decided that they want to drink some tea. Of course, no two people can use the same teapot simultaneously, so the students had to form a queue to get their tea.
i-th student comes to the end of the queue at the beginning of li-th second. If there are multiple students coming to the queue in the same moment, then the student with greater index comes after the student with lesser index. Students in the queue behave as follows: if there is nobody in the queue before the student, then he uses the teapot for exactly one second and leaves the queue with his tea; otherwise the student waits for the people before him to get their tea. If at the beginning of ri-th second student i still cannot get his tea (there is someone before him in the queue), then he leaves the queue without getting any tea.
For each student determine the second he will use the teapot and get his tea (if he actually gets it).
Input
The first line contains one integer t β the number of test cases to solve (1 β€ t β€ 1000).
Then t test cases follow. The first line of each test case contains one integer n (1 β€ n β€ 1000) β the number of students.
Then n lines follow. Each line contains two integer li, ri (1 β€ li β€ ri β€ 5000) β the second i-th student comes to the end of the queue, and the second he leaves the queue if he still cannot get his tea.
It is guaranteed that for every <image> condition li - 1 β€ li holds.
The sum of n over all test cases doesn't exceed 1000.
Note that in hacks you have to set t = 1.
Output
For each test case print n integers. i-th of them must be equal to the second when i-th student gets his tea, or 0 if he leaves without tea.
Example
Input
2
2
1 3
1 4
3
1 5
1 1
2 3
Output
1 2
1 0 2
Note
The example contains 2 tests:
1. During 1-st second, students 1 and 2 come to the queue, and student 1 gets his tea. Student 2 gets his tea during 2-nd second.
2. During 1-st second, students 1 and 2 come to the queue, student 1 gets his tea, and student 2 leaves without tea. During 2-nd second, student 3 comes and gets his tea. | instruction | 0 | 96,702 | 14 | 193,404 |
Tags: implementation
Correct Solution:
```
n=int(input())
t=0
for x in range(n):
p=int(input())
ol=[]
sl=[]
na=[]
ki=[]
pi=[]
t=0
for y in range(p):
v,c=list(map(int,input().split()))
ol.append(v)
sl.append(c)
for z in range(p):
sam=min(ol)
kp=ol.index(sam)
pi.append(kp)
if t<min(ol):
t=min(ol)+1
ki.append(min(ol))
ol[kp]=5555555
elif t==min(ol):
t+=1
ki.append(min(ol))
ol[kp]=55555555
else:
if sl[kp]>=t:
ki.append(t)
t+=1
ol[kp]=555555555
else:
ki.append(0)
ol[kp]=55555555
for r in range(0,p):
oll=pi.index(r)
na.append(ki[oll])
print(*na)
``` | output | 1 | 96,702 | 14 | 193,405 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently n students from city S moved to city P to attend a programming camp.
They moved there by train. In the evening, all students in the train decided that they want to drink some tea. Of course, no two people can use the same teapot simultaneously, so the students had to form a queue to get their tea.
i-th student comes to the end of the queue at the beginning of li-th second. If there are multiple students coming to the queue in the same moment, then the student with greater index comes after the student with lesser index. Students in the queue behave as follows: if there is nobody in the queue before the student, then he uses the teapot for exactly one second and leaves the queue with his tea; otherwise the student waits for the people before him to get their tea. If at the beginning of ri-th second student i still cannot get his tea (there is someone before him in the queue), then he leaves the queue without getting any tea.
For each student determine the second he will use the teapot and get his tea (if he actually gets it).
Input
The first line contains one integer t β the number of test cases to solve (1 β€ t β€ 1000).
Then t test cases follow. The first line of each test case contains one integer n (1 β€ n β€ 1000) β the number of students.
Then n lines follow. Each line contains two integer li, ri (1 β€ li β€ ri β€ 5000) β the second i-th student comes to the end of the queue, and the second he leaves the queue if he still cannot get his tea.
It is guaranteed that for every <image> condition li - 1 β€ li holds.
The sum of n over all test cases doesn't exceed 1000.
Note that in hacks you have to set t = 1.
Output
For each test case print n integers. i-th of them must be equal to the second when i-th student gets his tea, or 0 if he leaves without tea.
Example
Input
2
2
1 3
1 4
3
1 5
1 1
2 3
Output
1 2
1 0 2
Note
The example contains 2 tests:
1. During 1-st second, students 1 and 2 come to the queue, and student 1 gets his tea. Student 2 gets his tea during 2-nd second.
2. During 1-st second, students 1 and 2 come to the queue, student 1 gets his tea, and student 2 leaves without tea. During 2-nd second, student 3 comes and gets his tea.
Submitted Solution:
```
# python 3
from collections import defaultdict
import math
from sys import stdin
casenumber = int(stdin.readline())
mydict=defaultdict(list)
output=[]
for i in range(casenumber):
n_student = int(stdin.readline())
outputlist=[]
l=[]
r=[]
for n in range(n_student):
string1 = stdin.readline().strip().split()
l_n=int(string1[0])
r_n=int(string1[1])
if l_n>len(l):
for count in range(l_n-len(l)):
l.append(0)
l.append(r_n)
else:
l.append(r_n)
if (len(l)-1)<=(r_n):
outputlist.append(len(l)-1)
else:
outputlist.append(0)
l.pop()
output.append(outputlist)
for i in range(casenumber):
for j in range(len(output[i])):
print(output[i][j],end=" ")
print('')
#
# B. Tea Queue
# time limit per test1 second
# memory limit per test256 megabytes
# inputstandard input
# outputstandard output
# Recently n students from city S moved to city P to attend a programming camp.
#
# They moved there by train. In the evening, all students in the train decided that they want to drink some tea. Of course, no two people can use the same teapot simultaneously, so the students had to form a queue to get their tea.
#
# i-th student comes to the end of the queue at the beginning of li-th second. If there are multiple students coming to the queue in the same moment, then the student with greater index comes after the student with lesser index. Students in the queue behave as follows: if there is nobody in the queue before the student, then he uses the teapot for exactly one second and leaves the queue with his tea; otherwise the student waits for the people before him to get their tea. If at the beginning of ri-th second student i still cannot get his tea (there is someone before him in the queue), then he leaves the queue without getting any tea.
#
# For each student determine the second he will use the teapot and get his tea (if he actually gets it).
#
# Input
# The first line contains one integer t β the number of test cases to solve (1ββ€βtββ€β1000).
#
# Then t test cases follow. The first line of each test case contains one integer n (1ββ€βnββ€β1000) β the number of students.
#
# Then n lines follow. Each line contains two integer li, ri (1ββ€βliββ€βriββ€β5000) β the second i-th student comes to the end of the queue, and the second he leaves the queue if he still cannot get his tea.
#
# It is guaranteed that for every condition liβ-β1ββ€βli holds.
#
# The sum of n over all test cases doesn't exceed 1000.
#
# Note that in hacks you have to set tβ=β1.
#
# Output
# For each test case print n integers. i-th of them must be equal to the second when i-th student gets his tea, or 0 if he leaves without tea.
#
# Example
# input
# 2
# 2
# 1 3
# 1 4
# 3
# 1 5
# 1 1
# 2 3
# output
# 1 2
# 1 0 2
# Note
# The example contains 2 tests:
#
# During 1-st second, students 1 and 2 come to the queue, and student 1 gets his tea. Student 2 gets his tea during 2-nd second.
# During 1-st second, students 1 and 2 come to the queue, student 1 gets his tea, and student 2 leaves without tea. During 2-nd second, student 3 comes and gets his tea.
``` | instruction | 0 | 96,703 | 14 | 193,406 |
Yes | output | 1 | 96,703 | 14 | 193,407 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently n students from city S moved to city P to attend a programming camp.
They moved there by train. In the evening, all students in the train decided that they want to drink some tea. Of course, no two people can use the same teapot simultaneously, so the students had to form a queue to get their tea.
i-th student comes to the end of the queue at the beginning of li-th second. If there are multiple students coming to the queue in the same moment, then the student with greater index comes after the student with lesser index. Students in the queue behave as follows: if there is nobody in the queue before the student, then he uses the teapot for exactly one second and leaves the queue with his tea; otherwise the student waits for the people before him to get their tea. If at the beginning of ri-th second student i still cannot get his tea (there is someone before him in the queue), then he leaves the queue without getting any tea.
For each student determine the second he will use the teapot and get his tea (if he actually gets it).
Input
The first line contains one integer t β the number of test cases to solve (1 β€ t β€ 1000).
Then t test cases follow. The first line of each test case contains one integer n (1 β€ n β€ 1000) β the number of students.
Then n lines follow. Each line contains two integer li, ri (1 β€ li β€ ri β€ 5000) β the second i-th student comes to the end of the queue, and the second he leaves the queue if he still cannot get his tea.
It is guaranteed that for every <image> condition li - 1 β€ li holds.
The sum of n over all test cases doesn't exceed 1000.
Note that in hacks you have to set t = 1.
Output
For each test case print n integers. i-th of them must be equal to the second when i-th student gets his tea, or 0 if he leaves without tea.
Example
Input
2
2
1 3
1 4
3
1 5
1 1
2 3
Output
1 2
1 0 2
Note
The example contains 2 tests:
1. During 1-st second, students 1 and 2 come to the queue, and student 1 gets his tea. Student 2 gets his tea during 2-nd second.
2. During 1-st second, students 1 and 2 come to the queue, student 1 gets his tea, and student 2 leaves without tea. During 2-nd second, student 3 comes and gets his tea.
Submitted Solution:
```
t = int(input())
for _ in range(t):
n = int(input())
lims = [tuple(int(v) for v in input().split()) for _ in range(n)]
ctime = 0
ans = []
for l, r in lims:
if l >= ctime:
ans.append(l)
ctime = l + 1
elif r < ctime:
ans.append(0)
else:
ans.append(ctime)
ctime += 1
print(' '.join(str(v) for v in ans))
``` | instruction | 0 | 96,704 | 14 | 193,408 |
Yes | output | 1 | 96,704 | 14 | 193,409 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently n students from city S moved to city P to attend a programming camp.
They moved there by train. In the evening, all students in the train decided that they want to drink some tea. Of course, no two people can use the same teapot simultaneously, so the students had to form a queue to get their tea.
i-th student comes to the end of the queue at the beginning of li-th second. If there are multiple students coming to the queue in the same moment, then the student with greater index comes after the student with lesser index. Students in the queue behave as follows: if there is nobody in the queue before the student, then he uses the teapot for exactly one second and leaves the queue with his tea; otherwise the student waits for the people before him to get their tea. If at the beginning of ri-th second student i still cannot get his tea (there is someone before him in the queue), then he leaves the queue without getting any tea.
For each student determine the second he will use the teapot and get his tea (if he actually gets it).
Input
The first line contains one integer t β the number of test cases to solve (1 β€ t β€ 1000).
Then t test cases follow. The first line of each test case contains one integer n (1 β€ n β€ 1000) β the number of students.
Then n lines follow. Each line contains two integer li, ri (1 β€ li β€ ri β€ 5000) β the second i-th student comes to the end of the queue, and the second he leaves the queue if he still cannot get his tea.
It is guaranteed that for every <image> condition li - 1 β€ li holds.
The sum of n over all test cases doesn't exceed 1000.
Note that in hacks you have to set t = 1.
Output
For each test case print n integers. i-th of them must be equal to the second when i-th student gets his tea, or 0 if he leaves without tea.
Example
Input
2
2
1 3
1 4
3
1 5
1 1
2 3
Output
1 2
1 0 2
Note
The example contains 2 tests:
1. During 1-st second, students 1 and 2 come to the queue, and student 1 gets his tea. Student 2 gets his tea during 2-nd second.
2. During 1-st second, students 1 and 2 come to the queue, student 1 gets his tea, and student 2 leaves without tea. During 2-nd second, student 3 comes and gets his tea.
Submitted Solution:
```
# Put them all in queue in order of l. At popping check: should they be in? (time++)Should they be already out? (0)
t = int(input())
for _ in range(t):
n = int(input())
arr = [[int(i) for i in input().split()] + [i] for i in range(n)]
timearr = [0 for i in range(n)]
checked = 0
currtime = 1
arr.sort(key=lambda a:a[0])
while checked < n:
if arr[checked][0] > currtime:
currtime += 1
elif arr[checked][1] < currtime:
checked += 1
else:
timearr[arr[checked][2]] = currtime
currtime += 1
checked += 1
print(' '.join(str(i) for i in timearr))
``` | instruction | 0 | 96,705 | 14 | 193,410 |
Yes | output | 1 | 96,705 | 14 | 193,411 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently n students from city S moved to city P to attend a programming camp.
They moved there by train. In the evening, all students in the train decided that they want to drink some tea. Of course, no two people can use the same teapot simultaneously, so the students had to form a queue to get their tea.
i-th student comes to the end of the queue at the beginning of li-th second. If there are multiple students coming to the queue in the same moment, then the student with greater index comes after the student with lesser index. Students in the queue behave as follows: if there is nobody in the queue before the student, then he uses the teapot for exactly one second and leaves the queue with his tea; otherwise the student waits for the people before him to get their tea. If at the beginning of ri-th second student i still cannot get his tea (there is someone before him in the queue), then he leaves the queue without getting any tea.
For each student determine the second he will use the teapot and get his tea (if he actually gets it).
Input
The first line contains one integer t β the number of test cases to solve (1 β€ t β€ 1000).
Then t test cases follow. The first line of each test case contains one integer n (1 β€ n β€ 1000) β the number of students.
Then n lines follow. Each line contains two integer li, ri (1 β€ li β€ ri β€ 5000) β the second i-th student comes to the end of the queue, and the second he leaves the queue if he still cannot get his tea.
It is guaranteed that for every <image> condition li - 1 β€ li holds.
The sum of n over all test cases doesn't exceed 1000.
Note that in hacks you have to set t = 1.
Output
For each test case print n integers. i-th of them must be equal to the second when i-th student gets his tea, or 0 if he leaves without tea.
Example
Input
2
2
1 3
1 4
3
1 5
1 1
2 3
Output
1 2
1 0 2
Note
The example contains 2 tests:
1. During 1-st second, students 1 and 2 come to the queue, and student 1 gets his tea. Student 2 gets his tea during 2-nd second.
2. During 1-st second, students 1 and 2 come to the queue, student 1 gets his tea, and student 2 leaves without tea. During 2-nd second, student 3 comes and gets his tea.
Submitted Solution:
```
t = int(input())
ans1 = []
for i in range(t):
n=int(input())
st=[]
for i in range(n):
l,r = map(int,input().split())
st.append((l,r,i))
st = sorted(st, key=lambda x: (x[0], x[2]))
ans = []
f = -1
for s in st:
if s[1] < f:
ans.append(0)
else:
ans.append(max(f, s[0]))
f = ans[-1]+1
ans1.append(ans)
for ans2 in ans1:
print(' '.join([str(i) for i in ans2]))
``` | instruction | 0 | 96,706 | 14 | 193,412 |
Yes | output | 1 | 96,706 | 14 | 193,413 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently n students from city S moved to city P to attend a programming camp.
They moved there by train. In the evening, all students in the train decided that they want to drink some tea. Of course, no two people can use the same teapot simultaneously, so the students had to form a queue to get their tea.
i-th student comes to the end of the queue at the beginning of li-th second. If there are multiple students coming to the queue in the same moment, then the student with greater index comes after the student with lesser index. Students in the queue behave as follows: if there is nobody in the queue before the student, then he uses the teapot for exactly one second and leaves the queue with his tea; otherwise the student waits for the people before him to get their tea. If at the beginning of ri-th second student i still cannot get his tea (there is someone before him in the queue), then he leaves the queue without getting any tea.
For each student determine the second he will use the teapot and get his tea (if he actually gets it).
Input
The first line contains one integer t β the number of test cases to solve (1 β€ t β€ 1000).
Then t test cases follow. The first line of each test case contains one integer n (1 β€ n β€ 1000) β the number of students.
Then n lines follow. Each line contains two integer li, ri (1 β€ li β€ ri β€ 5000) β the second i-th student comes to the end of the queue, and the second he leaves the queue if he still cannot get his tea.
It is guaranteed that for every <image> condition li - 1 β€ li holds.
The sum of n over all test cases doesn't exceed 1000.
Note that in hacks you have to set t = 1.
Output
For each test case print n integers. i-th of them must be equal to the second when i-th student gets his tea, or 0 if he leaves without tea.
Example
Input
2
2
1 3
1 4
3
1 5
1 1
2 3
Output
1 2
1 0 2
Note
The example contains 2 tests:
1. During 1-st second, students 1 and 2 come to the queue, and student 1 gets his tea. Student 2 gets his tea during 2-nd second.
2. During 1-st second, students 1 and 2 come to the queue, student 1 gets his tea, and student 2 leaves without tea. During 2-nd second, student 3 comes and gets his tea.
Submitted Solution:
```
_ = int(input())
while _>0:
A = []
B = []
n = int(input())
for i in range(n):
p, q = map(int, input().split())
A.append([p, i, q])
A = sorted(A)
i = 0
k = A[0][0]
while i < len(A):
k = max(k + 1, A[i][0]) if i > 0 else k
while i < len(A) and max(k, A[i][0]) > A[i][2]:
del A[i]
B.append(0)
if i < len(A):B.append(k)
i += 1
print(' '.join(map(str,B)))
_-=1
``` | instruction | 0 | 96,707 | 14 | 193,414 |
No | output | 1 | 96,707 | 14 | 193,415 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently n students from city S moved to city P to attend a programming camp.
They moved there by train. In the evening, all students in the train decided that they want to drink some tea. Of course, no two people can use the same teapot simultaneously, so the students had to form a queue to get their tea.
i-th student comes to the end of the queue at the beginning of li-th second. If there are multiple students coming to the queue in the same moment, then the student with greater index comes after the student with lesser index. Students in the queue behave as follows: if there is nobody in the queue before the student, then he uses the teapot for exactly one second and leaves the queue with his tea; otherwise the student waits for the people before him to get their tea. If at the beginning of ri-th second student i still cannot get his tea (there is someone before him in the queue), then he leaves the queue without getting any tea.
For each student determine the second he will use the teapot and get his tea (if he actually gets it).
Input
The first line contains one integer t β the number of test cases to solve (1 β€ t β€ 1000).
Then t test cases follow. The first line of each test case contains one integer n (1 β€ n β€ 1000) β the number of students.
Then n lines follow. Each line contains two integer li, ri (1 β€ li β€ ri β€ 5000) β the second i-th student comes to the end of the queue, and the second he leaves the queue if he still cannot get his tea.
It is guaranteed that for every <image> condition li - 1 β€ li holds.
The sum of n over all test cases doesn't exceed 1000.
Note that in hacks you have to set t = 1.
Output
For each test case print n integers. i-th of them must be equal to the second when i-th student gets his tea, or 0 if he leaves without tea.
Example
Input
2
2
1 3
1 4
3
1 5
1 1
2 3
Output
1 2
1 0 2
Note
The example contains 2 tests:
1. During 1-st second, students 1 and 2 come to the queue, and student 1 gets his tea. Student 2 gets his tea during 2-nd second.
2. During 1-st second, students 1 and 2 come to the queue, student 1 gets his tea, and student 2 leaves without tea. During 2-nd second, student 3 comes and gets his tea.
Submitted Solution:
```
from collections import Counter as cntr
from math import inf
def cin():
return map(int, input().split(' '))
t = int(input())
for i in range(t):
l=[]
r=[]
n = int(input())
for i in range(n):
a, b = cin()
l.append(a)
r.append(b)
m = r[-1]
timer = 1
ans = []
for j in range(n):
if l[j]<=timer:
if r[j] >= timer:
ans.append(timer)
timer += 1
else:
ans.append(0)
else:
timer += 1
print(*ans)
``` | instruction | 0 | 96,708 | 14 | 193,416 |
No | output | 1 | 96,708 | 14 | 193,417 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently n students from city S moved to city P to attend a programming camp.
They moved there by train. In the evening, all students in the train decided that they want to drink some tea. Of course, no two people can use the same teapot simultaneously, so the students had to form a queue to get their tea.
i-th student comes to the end of the queue at the beginning of li-th second. If there are multiple students coming to the queue in the same moment, then the student with greater index comes after the student with lesser index. Students in the queue behave as follows: if there is nobody in the queue before the student, then he uses the teapot for exactly one second and leaves the queue with his tea; otherwise the student waits for the people before him to get their tea. If at the beginning of ri-th second student i still cannot get his tea (there is someone before him in the queue), then he leaves the queue without getting any tea.
For each student determine the second he will use the teapot and get his tea (if he actually gets it).
Input
The first line contains one integer t β the number of test cases to solve (1 β€ t β€ 1000).
Then t test cases follow. The first line of each test case contains one integer n (1 β€ n β€ 1000) β the number of students.
Then n lines follow. Each line contains two integer li, ri (1 β€ li β€ ri β€ 5000) β the second i-th student comes to the end of the queue, and the second he leaves the queue if he still cannot get his tea.
It is guaranteed that for every <image> condition li - 1 β€ li holds.
The sum of n over all test cases doesn't exceed 1000.
Note that in hacks you have to set t = 1.
Output
For each test case print n integers. i-th of them must be equal to the second when i-th student gets his tea, or 0 if he leaves without tea.
Example
Input
2
2
1 3
1 4
3
1 5
1 1
2 3
Output
1 2
1 0 2
Note
The example contains 2 tests:
1. During 1-st second, students 1 and 2 come to the queue, and student 1 gets his tea. Student 2 gets his tea during 2-nd second.
2. During 1-st second, students 1 and 2 come to the queue, student 1 gets his tea, and student 2 leaves without tea. During 2-nd second, student 3 comes and gets his tea.
Submitted Solution:
```
t=int(input())
for i in range(t):
n=int(input())
L=[]
res=[]
for j in range(n):
l,r=map(int,input().split())
L.insert(0,(l,r))
sec=L[-1][0]
while len(L)!=0:
tup=L.pop()
if tup[0]<=sec and tup[1]>=sec:
res.append(sec)
sec+=1
else:
res.append(0)
print(*res)
``` | instruction | 0 | 96,709 | 14 | 193,418 |
No | output | 1 | 96,709 | 14 | 193,419 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently n students from city S moved to city P to attend a programming camp.
They moved there by train. In the evening, all students in the train decided that they want to drink some tea. Of course, no two people can use the same teapot simultaneously, so the students had to form a queue to get their tea.
i-th student comes to the end of the queue at the beginning of li-th second. If there are multiple students coming to the queue in the same moment, then the student with greater index comes after the student with lesser index. Students in the queue behave as follows: if there is nobody in the queue before the student, then he uses the teapot for exactly one second and leaves the queue with his tea; otherwise the student waits for the people before him to get their tea. If at the beginning of ri-th second student i still cannot get his tea (there is someone before him in the queue), then he leaves the queue without getting any tea.
For each student determine the second he will use the teapot and get his tea (if he actually gets it).
Input
The first line contains one integer t β the number of test cases to solve (1 β€ t β€ 1000).
Then t test cases follow. The first line of each test case contains one integer n (1 β€ n β€ 1000) β the number of students.
Then n lines follow. Each line contains two integer li, ri (1 β€ li β€ ri β€ 5000) β the second i-th student comes to the end of the queue, and the second he leaves the queue if he still cannot get his tea.
It is guaranteed that for every <image> condition li - 1 β€ li holds.
The sum of n over all test cases doesn't exceed 1000.
Note that in hacks you have to set t = 1.
Output
For each test case print n integers. i-th of them must be equal to the second when i-th student gets his tea, or 0 if he leaves without tea.
Example
Input
2
2
1 3
1 4
3
1 5
1 1
2 3
Output
1 2
1 0 2
Note
The example contains 2 tests:
1. During 1-st second, students 1 and 2 come to the queue, and student 1 gets his tea. Student 2 gets his tea during 2-nd second.
2. During 1-st second, students 1 and 2 come to the queue, student 1 gets his tea, and student 2 leaves without tea. During 2-nd second, student 3 comes and gets his tea.
Submitted Solution:
```
t=int(input())
for i in range(t):
n=int(input())
L=[]
res=[]
for j in range(n):
l,r=map(int,input().split())
L.insert(0,(l,r))
sec=L[-1][0]
while len(L)!=0:
tup=L.pop()
if tup[0]<=sec:
if tup[1]>=sec:
res.append(sec)
sec+=1
else:
res.append(0)
else:
sec=tup[0]
res.append(sec)
print(*res)
``` | instruction | 0 | 96,710 | 14 | 193,420 |
No | output | 1 | 96,710 | 14 | 193,421 |
Provide a correct Python 3 solution for this coding contest problem.
JOI has a stove in your room. JOI himself is resistant to the cold, so he doesn't need to put on the stove when he is alone in the room, but he needs to put on the stove when there are visitors.
On this day, there are N guests under JOI. The ith (1 \ leq i \ leq N) visitor arrives at time T_i and leaves at time T_i + 1. There can never be more than one visitor at the same time.
JOI can turn the stove on and off at any time. However, each time you turn on the stove, you will consume one match. JOI has only K matches, so he can only stove up to K times. The stove is gone at the beginning of the day.
When the stove is on, fuel is consumed by that amount, so I want to set the time when the stove is on and off and minimize the total time when the stove is on.
Example
Input
3 2
1
3
6
Output
4 | instruction | 0 | 96,897 | 14 | 193,794 |
"Correct Solution:
```
#!/usr/bin/python3
import os
import sys
def main():
N, K = read_ints()
T = [read_int() for _ in range(N)]
print(solve(N, K, T))
def solve(N, K, T):
diffs = [T[i + 1] - T[i] for i in range(N - 1)]
diffs.sort()
t = N
for i in range(N - K):
t += diffs[i] - 1
return t
###############################################################################
DEBUG = 'DEBUG' in os.environ
def inp():
return sys.stdin.readline().rstrip()
def read_int():
return int(inp())
def read_ints():
return [int(e) for e in inp().split()]
def dprint(*value, sep=' ', end='\n'):
if DEBUG:
print(*value, sep=sep, end=end)
if __name__ == '__main__':
main()
``` | output | 1 | 96,897 | 14 | 193,795 |
Provide a correct Python 3 solution for this coding contest problem.
JOI has a stove in your room. JOI himself is resistant to the cold, so he doesn't need to put on the stove when he is alone in the room, but he needs to put on the stove when there are visitors.
On this day, there are N guests under JOI. The ith (1 \ leq i \ leq N) visitor arrives at time T_i and leaves at time T_i + 1. There can never be more than one visitor at the same time.
JOI can turn the stove on and off at any time. However, each time you turn on the stove, you will consume one match. JOI has only K matches, so he can only stove up to K times. The stove is gone at the beginning of the day.
When the stove is on, fuel is consumed by that amount, so I want to set the time when the stove is on and off and minimize the total time when the stove is on.
Example
Input
3 2
1
3
6
Output
4 | instruction | 0 | 96,898 | 14 | 193,796 |
"Correct Solution:
```
from bisect import bisect
N, K, *T = map(int, open(0).read().split())
S = [(T[i+1] - T[i])-1 for i in range(N-1)]
S.sort(reverse=1)
print((T[-1] - T[0] + 1) - sum(S[:K-1]))
``` | output | 1 | 96,898 | 14 | 193,797 |
Provide a correct Python 3 solution for this coding contest problem.
JOI has a stove in your room. JOI himself is resistant to the cold, so he doesn't need to put on the stove when he is alone in the room, but he needs to put on the stove when there are visitors.
On this day, there are N guests under JOI. The ith (1 \ leq i \ leq N) visitor arrives at time T_i and leaves at time T_i + 1. There can never be more than one visitor at the same time.
JOI can turn the stove on and off at any time. However, each time you turn on the stove, you will consume one match. JOI has only K matches, so he can only stove up to K times. The stove is gone at the beginning of the day.
When the stove is on, fuel is consumed by that amount, so I want to set the time when the stove is on and off and minimize the total time when the stove is on.
Example
Input
3 2
1
3
6
Output
4 | instruction | 0 | 96,899 | 14 | 193,798 |
"Correct Solution:
```
n, k = map(int, input().split())
diff = []
ti = int(input()) + 1
for _ in range(n - 1):
ti1 = int(input())
diff.append(ti1 - ti)
ti = ti1 + 1
if n <= k:
print(n)
else:
diff.sort()
print(n + sum(diff[:n - k]))
``` | output | 1 | 96,899 | 14 | 193,799 |
Provide a correct Python 3 solution for this coding contest problem.
JOI has a stove in your room. JOI himself is resistant to the cold, so he doesn't need to put on the stove when he is alone in the room, but he needs to put on the stove when there are visitors.
On this day, there are N guests under JOI. The ith (1 \ leq i \ leq N) visitor arrives at time T_i and leaves at time T_i + 1. There can never be more than one visitor at the same time.
JOI can turn the stove on and off at any time. However, each time you turn on the stove, you will consume one match. JOI has only K matches, so he can only stove up to K times. The stove is gone at the beginning of the day.
When the stove is on, fuel is consumed by that amount, so I want to set the time when the stove is on and off and minimize the total time when the stove is on.
Example
Input
3 2
1
3
6
Output
4 | instruction | 0 | 96,900 | 14 | 193,800 |
"Correct Solution:
```
n, k = map(int, input().split())
li = [int(input()) for i in range(n)]
diff = []
for j in range(n-1):
diff.append(li[j+1]-li[j]-1)
diff.sort(reverse=True)
print(n+sum(diff[k-1:]))
``` | output | 1 | 96,900 | 14 | 193,801 |
Provide a correct Python 3 solution for this coding contest problem.
JOI has a stove in your room. JOI himself is resistant to the cold, so he doesn't need to put on the stove when he is alone in the room, but he needs to put on the stove when there are visitors.
On this day, there are N guests under JOI. The ith (1 \ leq i \ leq N) visitor arrives at time T_i and leaves at time T_i + 1. There can never be more than one visitor at the same time.
JOI can turn the stove on and off at any time. However, each time you turn on the stove, you will consume one match. JOI has only K matches, so he can only stove up to K times. The stove is gone at the beginning of the day.
When the stove is on, fuel is consumed by that amount, so I want to set the time when the stove is on and off and minimize the total time when the stove is on.
Example
Input
3 2
1
3
6
Output
4 | instruction | 0 | 96,901 | 14 | 193,802 |
"Correct Solution:
```
n, k = map(int, input().split())
t = [int(input()) for _ in range(n)]
v = [0 for _ in range(n -1)]
for i in range(n - 1):
v[i] = t[i + 1] - t[i] - 1
v.sort(reverse = True)
print(t[-1] - t[0] + 1 - sum(v[:(k - 1)]))
``` | output | 1 | 96,901 | 14 | 193,803 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
JOI has a stove in your room. JOI himself is resistant to the cold, so he doesn't need to put on the stove when he is alone in the room, but he needs to put on the stove when there are visitors.
On this day, there are N guests under JOI. The ith (1 \ leq i \ leq N) visitor arrives at time T_i and leaves at time T_i + 1. There can never be more than one visitor at the same time.
JOI can turn the stove on and off at any time. However, each time you turn on the stove, you will consume one match. JOI has only K matches, so he can only stove up to K times. The stove is gone at the beginning of the day.
When the stove is on, fuel is consumed by that amount, so I want to set the time when the stove is on and off and minimize the total time when the stove is on.
Example
Input
3 2
1
3
6
Output
4
Submitted Solution:
```
def gen_kcombination(lis,k):
if k >= len(lis):
return [lis]
kcombs = []
if k == 1:
return [[x] for x in lis]
for i in range(len(lis) - k+1):
kcombs += [[lis[i]] + x for x in gen_kcombination(lis[i+1:],k-1)]
return kcombs
n,k = map(int,input().split())
numbers = []
times = []
for i in range(n):
numbers.append(i)
times.append(int(input()))
candidates = [ [0] + x for x in gen_kcombination(numbers[1:],k-1)]
bestTime = times[-1] + 1
for i in range(len(candidates)):
candidate = candidates[i]
time = 0
for j in range(k-1):
igniteTime = times[candidate[j]]
extinguishTime = times[candidate[j+1]-1] + 1
time += extinguishTime - igniteTime
time += times[-1] + 1 - times[candidate[-1]]
if bestTime >= time:
bestTime = time
print(time)
``` | instruction | 0 | 96,902 | 14 | 193,804 |
No | output | 1 | 96,902 | 14 | 193,805 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Oh, New Year. The time to gather all your friends and reflect on the heartwarming events of the past year...
n friends live in a city which can be represented as a number line. The i-th friend lives in a house with an integer coordinate x_i. The i-th friend can come celebrate the New Year to the house with coordinate x_i-1, x_i+1 or stay at x_i. Each friend is allowed to move no more than once.
For all friends 1 β€ x_i β€ n holds, however, they can come to houses with coordinates 0 and n+1 (if their houses are at 1 or n, respectively).
For example, let the initial positions be x = [1, 2, 4, 4]. The final ones then can be [1, 3, 3, 4], [0, 2, 3, 3], [2, 2, 5, 5], [2, 1, 3, 5] and so on. The number of occupied houses is the number of distinct positions among the final ones.
So all friends choose the moves they want to perform. After that the number of occupied houses is calculated. What is the minimum and the maximum number of occupied houses can there be?
Input
The first line contains a single integer n (1 β€ n β€ 2 β
10^5) β the number of friends.
The second line contains n integers x_1, x_2, ..., x_n (1 β€ x_i β€ n) β the coordinates of the houses of the friends.
Output
Print two integers β the minimum and the maximum possible number of occupied houses after all moves are performed.
Examples
Input
4
1 2 4 4
Output
2 4
Input
9
1 1 8 8 8 4 4 4 4
Output
3 8
Input
7
4 3 7 1 4 3 3
Output
3 6
Note
In the first example friends can go to [2, 2, 3, 3]. So friend 1 goes to x_1+1, friend 2 stays at his house x_2, friend 3 goes to x_3-1 and friend 4 goes to x_4-1. [1, 1, 3, 3], [2, 2, 3, 3] or [2, 2, 4, 4] are also all valid options to obtain 2 occupied houses.
For the maximum number of occupied houses friends can go to [1, 2, 3, 4] or to [0, 2, 4, 5], for example. | instruction | 0 | 97,085 | 14 | 194,170 |
Tags: dp, greedy
Correct Solution:
```
def main():
n = int(input())
xx = [int(a) for a in input().split()]
counts = [0] * (n+3)
for x in xx:
counts[x] += 1
cmn = counts
cmx = counts.copy()
mn = 0
skip = 0
for c1, c2, c3 in zip(counts, counts[1:], counts[2:]):
if skip > 0:
skip -= 1
continue
if c1 > 0:
mn +=1
skip = 2
mx = 0
for i in range(len(counts)):
if counts[i] > 1:
counts[i] -= 1
counts[i+1] +=1
for i in range(len(counts)-1, -1, -1):
if counts[i] > 1:
counts[i] -= 1
counts[i-1] += 1
for c in counts:
if c > 0:
mx += 1
print(mn, mx)
if __name__ == "__main__":
main()
``` | output | 1 | 97,085 | 14 | 194,171 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Oh, New Year. The time to gather all your friends and reflect on the heartwarming events of the past year...
n friends live in a city which can be represented as a number line. The i-th friend lives in a house with an integer coordinate x_i. The i-th friend can come celebrate the New Year to the house with coordinate x_i-1, x_i+1 or stay at x_i. Each friend is allowed to move no more than once.
For all friends 1 β€ x_i β€ n holds, however, they can come to houses with coordinates 0 and n+1 (if their houses are at 1 or n, respectively).
For example, let the initial positions be x = [1, 2, 4, 4]. The final ones then can be [1, 3, 3, 4], [0, 2, 3, 3], [2, 2, 5, 5], [2, 1, 3, 5] and so on. The number of occupied houses is the number of distinct positions among the final ones.
So all friends choose the moves they want to perform. After that the number of occupied houses is calculated. What is the minimum and the maximum number of occupied houses can there be?
Input
The first line contains a single integer n (1 β€ n β€ 2 β
10^5) β the number of friends.
The second line contains n integers x_1, x_2, ..., x_n (1 β€ x_i β€ n) β the coordinates of the houses of the friends.
Output
Print two integers β the minimum and the maximum possible number of occupied houses after all moves are performed.
Examples
Input
4
1 2 4 4
Output
2 4
Input
9
1 1 8 8 8 4 4 4 4
Output
3 8
Input
7
4 3 7 1 4 3 3
Output
3 6
Note
In the first example friends can go to [2, 2, 3, 3]. So friend 1 goes to x_1+1, friend 2 stays at his house x_2, friend 3 goes to x_3-1 and friend 4 goes to x_4-1. [1, 1, 3, 3], [2, 2, 3, 3] or [2, 2, 4, 4] are also all valid options to obtain 2 occupied houses.
For the maximum number of occupied houses friends can go to [1, 2, 3, 4] or to [0, 2, 4, 5], for example. | instruction | 0 | 97,086 | 14 | 194,172 |
Tags: dp, greedy
Correct Solution:
```
n=int(input())
x=input().split()
for i in range(n):
x[i]=int(x[i])
x.sort()
if(n==1):print(1,1)
else:
ls=[]
visited=[0 for i in range(n+5)]
count=0
for i in range(n):
if(i==0):
count+=1
if(i==n-1):
ls.append([x[i],count])
visited[x[i]]=1
else:
if(x[i]==x[i-1]):
count+=1
if(i==n-1):
ls.append([x[i],count])
visited[x[i]]=1
else:
ls.append([x[i-1],count])
visited[x[i-1]]=1
count=1
if(i==n-1):
ls.append([x[i],count])
visited[x[i]]=1
count_max=len(ls)
ls.sort()
mark=[0 for i in range(n+5)]
for i in range(len(ls)):
if(ls[i][1]>2):
mark[ls[i][0]-1]=1
mark[ls[i][0]+1]=1
if(visited[ls[i][0]-1]==0 and visited[ls[i][0]+1]==0):
count_max+=2
visited[ls[i][0]-1]=1
visited[ls[i][0]+1]=1
elif(visited[ls[i][0]-1]==0):
count_max+=1
visited[ls[i][0]-1]=1
elif(visited[ls[i][0]+1]==0):
count_max+=1
visited[ls[i][0]+1]=1
elif(ls[i][1]==2):
if(mark[ls[i][0]]==1):
mark[ls[i][0]-1]=1
mark[ls[i][0]+1]=1
if(visited[ls[i][0]-1]==0 and visited[ls[i][0]+1]==0):
count_max+=2
visited[ls[i][0]-1]=1
visited[ls[i][0]+1]=1
elif(visited[ls[i][0]-1]==0):
count_max+=1
visited[ls[i][0]-1]=1
elif(visited[ls[i][0]+1]==0):
count_max+=1
visited[ls[i][0]+1]=1
else:
if(visited[ls[i][0]-1]==0):
count_max+=1
visited[ls[i][0]-1]=1
mark[ls[i][0]-1]=1
elif(visited[ls[i][0]+1]==0):
count_max+=1
visited[ls[i][0]+1]=1
mark[ls[i][0]+1]=1
else:
mark[ls[i][0]+1]=1
else:
if(mark[ls[i][0]]==1):
if(visited[ls[i][0]-1]==0):
count_max+=1
visited[ls[i][0]-1]=1
mark[ls[i][0]-1]=1
elif(visited[ls[i][0]+1]==0):
count_max+=1
visited[ls[i][0]+1]=1
mark[ls[i][0]+1]=1
else:
mark[ls[i][0]+1]=1
else:
if(visited[ls[i][0]-1]==0):
visited[ls[i][0]-1]=1
visited[ls[i][0]]=0
ls=[]
visited=[0 for i in range(n+5)]
count=0
for i in range(n):
if(i==0):
count+=1
if(i==n-1):
ls.append([x[i],count])
visited[x[i]]=1
else:
if(x[i]==x[i-1]):
count+=1
if(i==n-1):
ls.append([x[i],count])
visited[x[i]]=1
else:
ls.append([x[i-1],count])
visited[x[i-1]]=1
count=1
if(i==n-1):
ls.append([x[i],count])
visited[x[i]]=1
count_min=len(ls)
ls.sort()
mark=[0 for i in range(n+5)]
for i in range(len(ls)):
if(visited[ls[i][0]-1]==1 and mark[ls[i][0]]==0):
count_min-=1
mark[ls[i][0]-1]=1
visited[ls[i][0]]=0
elif(visited[ls[i][0]+1]==1 and mark[ls[i][0]]==0):
count_min-=1
mark[ls[i][0]+1]=1
visited[ls[i][0]]=0
elif(mark[ls[i][0]]==0):
mark[ls[i][0]+1]=1
visited[ls[i][0]]=0
visited[ls[i][0]+1]=1
print(count_min,count_max)
``` | output | 1 | 97,086 | 14 | 194,173 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Oh, New Year. The time to gather all your friends and reflect on the heartwarming events of the past year...
n friends live in a city which can be represented as a number line. The i-th friend lives in a house with an integer coordinate x_i. The i-th friend can come celebrate the New Year to the house with coordinate x_i-1, x_i+1 or stay at x_i. Each friend is allowed to move no more than once.
For all friends 1 β€ x_i β€ n holds, however, they can come to houses with coordinates 0 and n+1 (if their houses are at 1 or n, respectively).
For example, let the initial positions be x = [1, 2, 4, 4]. The final ones then can be [1, 3, 3, 4], [0, 2, 3, 3], [2, 2, 5, 5], [2, 1, 3, 5] and so on. The number of occupied houses is the number of distinct positions among the final ones.
So all friends choose the moves they want to perform. After that the number of occupied houses is calculated. What is the minimum and the maximum number of occupied houses can there be?
Input
The first line contains a single integer n (1 β€ n β€ 2 β
10^5) β the number of friends.
The second line contains n integers x_1, x_2, ..., x_n (1 β€ x_i β€ n) β the coordinates of the houses of the friends.
Output
Print two integers β the minimum and the maximum possible number of occupied houses after all moves are performed.
Examples
Input
4
1 2 4 4
Output
2 4
Input
9
1 1 8 8 8 4 4 4 4
Output
3 8
Input
7
4 3 7 1 4 3 3
Output
3 6
Note
In the first example friends can go to [2, 2, 3, 3]. So friend 1 goes to x_1+1, friend 2 stays at his house x_2, friend 3 goes to x_3-1 and friend 4 goes to x_4-1. [1, 1, 3, 3], [2, 2, 3, 3] or [2, 2, 4, 4] are also all valid options to obtain 2 occupied houses.
For the maximum number of occupied houses friends can go to [1, 2, 3, 4] or to [0, 2, 4, 5], for example. | instruction | 0 | 97,087 | 14 | 194,174 |
Tags: dp, greedy
Correct Solution:
```
n = int(input())
a_max, a_min = [0]*(n+10), [0]*(n+10)
for x in (map(int, input().split())):
a_max[x] += 1
a_min[x] += 1
ans_min = 0
for i in range(1, n+2):
if a_max[i] and a_max[i-1] == 0:
a_max[i-1] = 1
a_max[i] -= 1
if a_min[i-1]:
a_min[i-1] = a_min[i] = a_min[i+1] = 0
ans_min += 1
for i in range(n, -1, -1):
if a_max[i] and a_max[i+1] == 0:
a_max[i+1] = 1
a_max[i] -= 1
for i in range(1, n+1):
if a_max[i] > 1:
a_max[i] = 1
print(ans_min, sum(a_max))
``` | output | 1 | 97,087 | 14 | 194,175 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Oh, New Year. The time to gather all your friends and reflect on the heartwarming events of the past year...
n friends live in a city which can be represented as a number line. The i-th friend lives in a house with an integer coordinate x_i. The i-th friend can come celebrate the New Year to the house with coordinate x_i-1, x_i+1 or stay at x_i. Each friend is allowed to move no more than once.
For all friends 1 β€ x_i β€ n holds, however, they can come to houses with coordinates 0 and n+1 (if their houses are at 1 or n, respectively).
For example, let the initial positions be x = [1, 2, 4, 4]. The final ones then can be [1, 3, 3, 4], [0, 2, 3, 3], [2, 2, 5, 5], [2, 1, 3, 5] and so on. The number of occupied houses is the number of distinct positions among the final ones.
So all friends choose the moves they want to perform. After that the number of occupied houses is calculated. What is the minimum and the maximum number of occupied houses can there be?
Input
The first line contains a single integer n (1 β€ n β€ 2 β
10^5) β the number of friends.
The second line contains n integers x_1, x_2, ..., x_n (1 β€ x_i β€ n) β the coordinates of the houses of the friends.
Output
Print two integers β the minimum and the maximum possible number of occupied houses after all moves are performed.
Examples
Input
4
1 2 4 4
Output
2 4
Input
9
1 1 8 8 8 4 4 4 4
Output
3 8
Input
7
4 3 7 1 4 3 3
Output
3 6
Note
In the first example friends can go to [2, 2, 3, 3]. So friend 1 goes to x_1+1, friend 2 stays at his house x_2, friend 3 goes to x_3-1 and friend 4 goes to x_4-1. [1, 1, 3, 3], [2, 2, 3, 3] or [2, 2, 4, 4] are also all valid options to obtain 2 occupied houses.
For the maximum number of occupied houses friends can go to [1, 2, 3, 4] or to [0, 2, 4, 5], for example. | instruction | 0 | 97,088 | 14 | 194,176 |
Tags: dp, greedy
Correct Solution:
```
n = int( input() )
arr = list( map(int, input().split()) )
vis = [0] * (n + 2)
frec = [0] * (n + 2)
for x in arr:
frec[x] += 1
arr.sort()
mx = 0
for x in arr:
if vis[x-1]==0:
mx += 1
vis[x-1] = 1
elif vis[x]==0:
mx += 1
vis[x] = 1
elif vis[x+1]==0:
mx += 1
vis[x+1] = 1
l, r = 2, n-1
mn_l = 0
mn_r = 0
while l <= n + 1:
if frec[l-1]:
mn_l += 1
l += 2
l += 1
while r >= 0:
if frec[r+1]:
mn_r += 1
r -= 2
r -= 1
print(min(mn_l, mn_r) , mx)
``` | output | 1 | 97,088 | 14 | 194,177 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Oh, New Year. The time to gather all your friends and reflect on the heartwarming events of the past year...
n friends live in a city which can be represented as a number line. The i-th friend lives in a house with an integer coordinate x_i. The i-th friend can come celebrate the New Year to the house with coordinate x_i-1, x_i+1 or stay at x_i. Each friend is allowed to move no more than once.
For all friends 1 β€ x_i β€ n holds, however, they can come to houses with coordinates 0 and n+1 (if their houses are at 1 or n, respectively).
For example, let the initial positions be x = [1, 2, 4, 4]. The final ones then can be [1, 3, 3, 4], [0, 2, 3, 3], [2, 2, 5, 5], [2, 1, 3, 5] and so on. The number of occupied houses is the number of distinct positions among the final ones.
So all friends choose the moves they want to perform. After that the number of occupied houses is calculated. What is the minimum and the maximum number of occupied houses can there be?
Input
The first line contains a single integer n (1 β€ n β€ 2 β
10^5) β the number of friends.
The second line contains n integers x_1, x_2, ..., x_n (1 β€ x_i β€ n) β the coordinates of the houses of the friends.
Output
Print two integers β the minimum and the maximum possible number of occupied houses after all moves are performed.
Examples
Input
4
1 2 4 4
Output
2 4
Input
9
1 1 8 8 8 4 4 4 4
Output
3 8
Input
7
4 3 7 1 4 3 3
Output
3 6
Note
In the first example friends can go to [2, 2, 3, 3]. So friend 1 goes to x_1+1, friend 2 stays at his house x_2, friend 3 goes to x_3-1 and friend 4 goes to x_4-1. [1, 1, 3, 3], [2, 2, 3, 3] or [2, 2, 4, 4] are also all valid options to obtain 2 occupied houses.
For the maximum number of occupied houses friends can go to [1, 2, 3, 4] or to [0, 2, 4, 5], for example. | instruction | 0 | 97,089 | 14 | 194,178 |
Tags: dp, greedy
Correct Solution:
```
import heapq
n, = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
a.sort()
ans = [0, 0]
last0 = None
last1 = None
for x in a:
if last0 == None or x - 1 > last0:
last0 = x + 1
ans[0] += 1
if last1 == None or x - 1 > last1 + 1:
last1 = x - 1
ans[1] += 1
elif x - 1 <= last1 + 1 <= x + 1:
last1 = last1 + 1
ans[1] += 1
print(ans[0], ans[1])
``` | output | 1 | 97,089 | 14 | 194,179 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Oh, New Year. The time to gather all your friends and reflect on the heartwarming events of the past year...
n friends live in a city which can be represented as a number line. The i-th friend lives in a house with an integer coordinate x_i. The i-th friend can come celebrate the New Year to the house with coordinate x_i-1, x_i+1 or stay at x_i. Each friend is allowed to move no more than once.
For all friends 1 β€ x_i β€ n holds, however, they can come to houses with coordinates 0 and n+1 (if their houses are at 1 or n, respectively).
For example, let the initial positions be x = [1, 2, 4, 4]. The final ones then can be [1, 3, 3, 4], [0, 2, 3, 3], [2, 2, 5, 5], [2, 1, 3, 5] and so on. The number of occupied houses is the number of distinct positions among the final ones.
So all friends choose the moves they want to perform. After that the number of occupied houses is calculated. What is the minimum and the maximum number of occupied houses can there be?
Input
The first line contains a single integer n (1 β€ n β€ 2 β
10^5) β the number of friends.
The second line contains n integers x_1, x_2, ..., x_n (1 β€ x_i β€ n) β the coordinates of the houses of the friends.
Output
Print two integers β the minimum and the maximum possible number of occupied houses after all moves are performed.
Examples
Input
4
1 2 4 4
Output
2 4
Input
9
1 1 8 8 8 4 4 4 4
Output
3 8
Input
7
4 3 7 1 4 3 3
Output
3 6
Note
In the first example friends can go to [2, 2, 3, 3]. So friend 1 goes to x_1+1, friend 2 stays at his house x_2, friend 3 goes to x_3-1 and friend 4 goes to x_4-1. [1, 1, 3, 3], [2, 2, 3, 3] or [2, 2, 4, 4] are also all valid options to obtain 2 occupied houses.
For the maximum number of occupied houses friends can go to [1, 2, 3, 4] or to [0, 2, 4, 5], for example. | instruction | 0 | 97,090 | 14 | 194,180 |
Tags: dp, greedy
Correct Solution:
```
n=int(input())
arr=list(map(int,input().split()))
v=[0]*200005
for i in arr:
v[i]+=1
p1=-1
p2=-1
l=0
h=0
for i in range(1,n+1):
if v[i] and p1<i-1:
l+=1
p1=i+1
if v[i] and p2<i-1:
h+=1
p2=i-1
v[i]-=1
if v[i] and p2<i:
h+=1
p2=i
v[i]-=1
if v[i] and p2<i+1:
h+=1
p2=i+1
v[i]-=1
print(l,h)
``` | output | 1 | 97,090 | 14 | 194,181 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Oh, New Year. The time to gather all your friends and reflect on the heartwarming events of the past year...
n friends live in a city which can be represented as a number line. The i-th friend lives in a house with an integer coordinate x_i. The i-th friend can come celebrate the New Year to the house with coordinate x_i-1, x_i+1 or stay at x_i. Each friend is allowed to move no more than once.
For all friends 1 β€ x_i β€ n holds, however, they can come to houses with coordinates 0 and n+1 (if their houses are at 1 or n, respectively).
For example, let the initial positions be x = [1, 2, 4, 4]. The final ones then can be [1, 3, 3, 4], [0, 2, 3, 3], [2, 2, 5, 5], [2, 1, 3, 5] and so on. The number of occupied houses is the number of distinct positions among the final ones.
So all friends choose the moves they want to perform. After that the number of occupied houses is calculated. What is the minimum and the maximum number of occupied houses can there be?
Input
The first line contains a single integer n (1 β€ n β€ 2 β
10^5) β the number of friends.
The second line contains n integers x_1, x_2, ..., x_n (1 β€ x_i β€ n) β the coordinates of the houses of the friends.
Output
Print two integers β the minimum and the maximum possible number of occupied houses after all moves are performed.
Examples
Input
4
1 2 4 4
Output
2 4
Input
9
1 1 8 8 8 4 4 4 4
Output
3 8
Input
7
4 3 7 1 4 3 3
Output
3 6
Note
In the first example friends can go to [2, 2, 3, 3]. So friend 1 goes to x_1+1, friend 2 stays at his house x_2, friend 3 goes to x_3-1 and friend 4 goes to x_4-1. [1, 1, 3, 3], [2, 2, 3, 3] or [2, 2, 4, 4] are also all valid options to obtain 2 occupied houses.
For the maximum number of occupied houses friends can go to [1, 2, 3, 4] or to [0, 2, 4, 5], for example. | instruction | 0 | 97,091 | 14 | 194,182 |
Tags: dp, greedy
Correct Solution:
```
import string
from collections import defaultdict,Counter
from math import sqrt, log10, log2, log, gcd, ceil, floor,factorial
from bisect import bisect_left, bisect_right
from itertools import permutations,combinations_with_replacement
import sys,io,os;
input=sys.stdin.readline
# input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
# print=sys.stdout.write
sys.setrecursionlimit(10000)
mod=int(pow(10,7)+9)
inf = float('inf')
def get_list():
return [int(i) for i in input().split()]
def yn(a):
print("YES" if a else "NO",flush=False)
t=1
for i in range(t):
n=int(input())
l=get_list()
l.sort()
seta2=set()
for i in l:
for j in range(i-1,i+2):
if j not in seta2:
seta2.add(j)
break;
l=sorted(set(l))
dict=defaultdict(int)
for i in l:
dict[i]=1
counter=0
for i in range(len(l)):
if i != len(l) - 1:
if dict[l[i]] and dict[l[i + 1]]:
if l[i] + 2 == l[i + 1]:
dict[l[i]] = 0
dict[l[i + 1]] = 0
counter += 1
if i<len(l)-2:
if dict[l[i]] and dict[l[i+1]] and dict[l[i+2]]:
if l[i]+1==l[i+1]==l[i+2]-1:
dict[l[i]]=0
dict[l[i+2]]=0
if i!=len(l)-1:
if dict[l[i]] and dict[l[i+1]]:
if l[i] + 1 == l[i + 1]:
dict[l[i + 1]] = 0
for i in range(len(l)-1):
if dict[l[i]] and dict[l[i+1]]:
if l[i]+1==l[i+1]:
dict[l[i+1]]=0
# print(dict)
print(counter+sum([dict[i] for i in l]),len(seta2))
"""
5
1 3 4 5 6
output: 2 5 (1 3 ) and (4 5 6)
6
1 2 3 5 6 7
output: 2 6
5
1 2 4 5 6
output: 2 5
5
1 3 5 6 7
output 2 5
"""
``` | output | 1 | 97,091 | 14 | 194,183 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Oh, New Year. The time to gather all your friends and reflect on the heartwarming events of the past year...
n friends live in a city which can be represented as a number line. The i-th friend lives in a house with an integer coordinate x_i. The i-th friend can come celebrate the New Year to the house with coordinate x_i-1, x_i+1 or stay at x_i. Each friend is allowed to move no more than once.
For all friends 1 β€ x_i β€ n holds, however, they can come to houses with coordinates 0 and n+1 (if their houses are at 1 or n, respectively).
For example, let the initial positions be x = [1, 2, 4, 4]. The final ones then can be [1, 3, 3, 4], [0, 2, 3, 3], [2, 2, 5, 5], [2, 1, 3, 5] and so on. The number of occupied houses is the number of distinct positions among the final ones.
So all friends choose the moves they want to perform. After that the number of occupied houses is calculated. What is the minimum and the maximum number of occupied houses can there be?
Input
The first line contains a single integer n (1 β€ n β€ 2 β
10^5) β the number of friends.
The second line contains n integers x_1, x_2, ..., x_n (1 β€ x_i β€ n) β the coordinates of the houses of the friends.
Output
Print two integers β the minimum and the maximum possible number of occupied houses after all moves are performed.
Examples
Input
4
1 2 4 4
Output
2 4
Input
9
1 1 8 8 8 4 4 4 4
Output
3 8
Input
7
4 3 7 1 4 3 3
Output
3 6
Note
In the first example friends can go to [2, 2, 3, 3]. So friend 1 goes to x_1+1, friend 2 stays at his house x_2, friend 3 goes to x_3-1 and friend 4 goes to x_4-1. [1, 1, 3, 3], [2, 2, 3, 3] or [2, 2, 4, 4] are also all valid options to obtain 2 occupied houses.
For the maximum number of occupied houses friends can go to [1, 2, 3, 4] or to [0, 2, 4, 5], for example. | instruction | 0 | 97,092 | 14 | 194,184 |
Tags: dp, greedy
Correct Solution:
```
n = int(input())
l = list(map(int, input().split()))
l1 = [0] * n
for i in range(n):
l1[i] = l[i]
l.sort()
l1 = list(set(l1))
l1.sort()
ans1 = 0
tem = l1[0]
for i in range(len(l1)):
if l1[i] - tem > 2:
ans1 -= -1
tem = l1[i]
ans1 -= -1
for i in range(n):
if i - 1 >= 0:
if l[i] - 1 != l[i - 1]:
l[i] = l[i] - 1
else:
if i + 1 <= n - 1:
if l[i + 1] < l[i]:
l[i], l[i + 1] = l[i + 1], l[i]
if l[i + 1] == l[i]:
l[i + 1] = l[i] + 1
else: l[i] = l[i] - 1
l = list(set(l))
ans2 = len(l)
print(ans1, ans2)
``` | output | 1 | 97,092 | 14 | 194,185 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.