message stringlengths 2 20.1k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 1.95k 109k | cluster float64 17 17 | __index_level_0__ int64 3.91k 217k |
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a game called "Unique Bid Auction". You can read more about it here: https://en.wikipedia.org/wiki/Unique_bid_auction (though you don't have to do it to solve this problem).
Let's simplify this game a bit. Formally, there are n participants, the i-th participant chose the number a_i. The winner of the game is such a participant that the number he chose is unique (i. e. nobody else chose this number except him) and is minimal (i. e. among all unique values of a the minimum one is the winning one).
Your task is to find the index of the participant who won the game (or -1 if there is no winner). Indexing is 1-based, i. e. the participants are numbered from 1 to n.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 2 ⋅ 10^4) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of participants. The second line of the test case contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ n), where a_i is the i-th participant chosen number.
It is guaranteed that the sum of n does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — the index of the participant who won the game (or -1 if there is no winner). Note that the answer is always unique.
Example
Input
6
2
1 1
3
2 1 3
4
2 2 2 3
1
1
5
2 3 2 4 2
6
1 1 5 5 4 4
Output
-1
2
4
1
2
-1 | instruction | 0 | 70,065 | 17 | 140,130 |
Tags: implementation
Correct Solution:
```
t = int(input())
def solve():
n = int(input())
arr = list(map(int, input().split()))
ans = -1
d = {}
for i in arr:
if i not in d:
d[i] = 1
else:
d[i] = 2
m = 9999999999999
ans = -1
for i, v in enumerate(arr):
if d[v] >= 2:
continue
else:
if v < m:
m = v
ans = i + 1
print(ans)
for _ in range(t):
solve()
``` | output | 1 | 70,065 | 17 | 140,131 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a game called "Unique Bid Auction". You can read more about it here: https://en.wikipedia.org/wiki/Unique_bid_auction (though you don't have to do it to solve this problem).
Let's simplify this game a bit. Formally, there are n participants, the i-th participant chose the number a_i. The winner of the game is such a participant that the number he chose is unique (i. e. nobody else chose this number except him) and is minimal (i. e. among all unique values of a the minimum one is the winning one).
Your task is to find the index of the participant who won the game (or -1 if there is no winner). Indexing is 1-based, i. e. the participants are numbered from 1 to n.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 2 ⋅ 10^4) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of participants. The second line of the test case contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ n), where a_i is the i-th participant chosen number.
It is guaranteed that the sum of n does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — the index of the participant who won the game (or -1 if there is no winner). Note that the answer is always unique.
Example
Input
6
2
1 1
3
2 1 3
4
2 2 2 3
1
1
5
2 3 2 4 2
6
1 1 5 5 4 4
Output
-1
2
4
1
2
-1 | instruction | 0 | 70,066 | 17 | 140,132 |
Tags: implementation
Correct Solution:
```
t = int(input())
for _ in range(t):
contagem = dict()
n = int(input())
aux = list(map(int,input().split()))
for i in range(n):
if aux[i] in contagem:
contagem[aux[i]].append(i+1)
else:
contagem[aux[i]] = [i+1]
res = -1
pos = 1e9
for i in sorted(contagem):
if len(contagem[i]) == 1:
res = contagem[i][0]
break
print(res)
``` | output | 1 | 70,066 | 17 | 140,133 |
Provide tags and a correct Python 3 solution for this coding contest problem.
On February, 30th n students came in the Center for Training Olympiad Programmers (CTOP) of the Berland State University. They came one by one, one after another. Each of them went in, and before sitting down at his desk, greeted with those who were present in the room by shaking hands. Each of the students who came in stayed in CTOP until the end of the day and never left.
At any time any three students could join together and start participating in a team contest, which lasted until the end of the day. The team did not distract from the contest for a minute, so when another student came in and greeted those who were present, he did not shake hands with the members of the contest writing team. Each team consisted of exactly three students, and each student could not become a member of more than one team. Different teams could start writing contest at different times.
Given how many present people shook the hands of each student, get a possible order in which the students could have come to CTOP. If such an order does not exist, then print that this is impossible.
Please note that some students could work independently until the end of the day, without participating in a team contest.
Input
The first line contains integer n (1 ≤ n ≤ 2·105) — the number of students who came to CTOP. The next line contains n integers a1, a2, ..., an (0 ≤ ai < n), where ai is the number of students with who the i-th student shook hands.
Output
If the sought order of students exists, print in the first line "Possible" and in the second line print the permutation of the students' numbers defining the order in which the students entered the center. Number i that stands to the left of number j in this permutation means that the i-th student came earlier than the j-th student. If there are multiple answers, print any of them.
If the sought order of students doesn't exist, in a single line print "Impossible".
Examples
Input
5
2 1 3 0 1
Output
Possible
4 5 1 3 2
Input
9
0 2 3 4 1 1 0 2 2
Output
Possible
7 5 2 1 6 8 3 4 9
Input
4
0 2 1 1
Output
Impossible
Note
In the first sample from the statement the order of events could be as follows:
* student 4 comes in (a4 = 0), he has no one to greet;
* student 5 comes in (a5 = 1), he shakes hands with student 4;
* student 1 comes in (a1 = 2), he shakes hands with two students (students 4, 5);
* student 3 comes in (a3 = 3), he shakes hands with three students (students 4, 5, 1);
* students 4, 5, 3 form a team and start writing a contest;
* student 2 comes in (a2 = 1), he shakes hands with one student (number 1).
In the second sample from the statement the order of events could be as follows:
* student 7 comes in (a7 = 0), he has nobody to greet;
* student 5 comes in (a5 = 1), he shakes hands with student 7;
* student 2 comes in (a2 = 2), he shakes hands with two students (students 7, 5);
* students 7, 5, 2 form a team and start writing a contest;
* student 1 comes in(a1 = 0), he has no one to greet (everyone is busy with the contest);
* student 6 comes in (a6 = 1), he shakes hands with student 1;
* student 8 comes in (a8 = 2), he shakes hands with two students (students 1, 6);
* student 3 comes in (a3 = 3), he shakes hands with three students (students 1, 6, 8);
* student 4 comes in (a4 = 4), he shakes hands with four students (students 1, 6, 8, 3);
* students 8, 3, 4 form a team and start writing a contest;
* student 9 comes in (a9 = 2), he shakes hands with two students (students 1, 6).
In the third sample from the statement the order of events is restored unambiguously:
* student 1 comes in (a1 = 0), he has no one to greet;
* student 3 comes in (or student 4) (a3 = a4 = 1), he shakes hands with student 1;
* student 2 comes in (a2 = 2), he shakes hands with two students (students 1, 3 (or 4));
* the remaining student 4 (or student 3), must shake one student's hand (a3 = a4 = 1) but it is impossible as there are only two scenarios: either a team formed and he doesn't greet anyone, or he greets all the three present people who work individually. | instruction | 0 | 70,227 | 17 | 140,454 |
Tags: binary search, constructive algorithms, data structures, greedy
Correct Solution:
```
def read_int():
return int(input().strip())
def read_ints():
return list(map(int, input().strip().split(' ')))
def solve():
"""
4 2 1 3 5
0 2 3 4 1 1 0 2 2
x x x x x x x x x
1 5 8 3 4 2 7 6 9
10
0 3 4 2
0 1 2 3 4 5
"""
N = read_int()
shakes = [[] for _ in range(N)]
for i, a in enumerate(read_ints(), start=1):
shakes[a].append(i)
i = 0
answer = []
while N > 0:
if len(shakes[i]) > 0:
answer.append(shakes[i].pop())
N -= 1
i += 1
else:
j = i
while j >= 0 and len(shakes[j]) == 0:
j -= 3
if j < 0:
break
i = j
if N != 0:
return 'Impossible'
print('Possible')
return ' '.join(map(str, answer))
if __name__ == '__main__':
print(solve())
``` | output | 1 | 70,227 | 17 | 140,455 |
Provide tags and a correct Python 3 solution for this coding contest problem.
On February, 30th n students came in the Center for Training Olympiad Programmers (CTOP) of the Berland State University. They came one by one, one after another. Each of them went in, and before sitting down at his desk, greeted with those who were present in the room by shaking hands. Each of the students who came in stayed in CTOP until the end of the day and never left.
At any time any three students could join together and start participating in a team contest, which lasted until the end of the day. The team did not distract from the contest for a minute, so when another student came in and greeted those who were present, he did not shake hands with the members of the contest writing team. Each team consisted of exactly three students, and each student could not become a member of more than one team. Different teams could start writing contest at different times.
Given how many present people shook the hands of each student, get a possible order in which the students could have come to CTOP. If such an order does not exist, then print that this is impossible.
Please note that some students could work independently until the end of the day, without participating in a team contest.
Input
The first line contains integer n (1 ≤ n ≤ 2·105) — the number of students who came to CTOP. The next line contains n integers a1, a2, ..., an (0 ≤ ai < n), where ai is the number of students with who the i-th student shook hands.
Output
If the sought order of students exists, print in the first line "Possible" and in the second line print the permutation of the students' numbers defining the order in which the students entered the center. Number i that stands to the left of number j in this permutation means that the i-th student came earlier than the j-th student. If there are multiple answers, print any of them.
If the sought order of students doesn't exist, in a single line print "Impossible".
Examples
Input
5
2 1 3 0 1
Output
Possible
4 5 1 3 2
Input
9
0 2 3 4 1 1 0 2 2
Output
Possible
7 5 2 1 6 8 3 4 9
Input
4
0 2 1 1
Output
Impossible
Note
In the first sample from the statement the order of events could be as follows:
* student 4 comes in (a4 = 0), he has no one to greet;
* student 5 comes in (a5 = 1), he shakes hands with student 4;
* student 1 comes in (a1 = 2), he shakes hands with two students (students 4, 5);
* student 3 comes in (a3 = 3), he shakes hands with three students (students 4, 5, 1);
* students 4, 5, 3 form a team and start writing a contest;
* student 2 comes in (a2 = 1), he shakes hands with one student (number 1).
In the second sample from the statement the order of events could be as follows:
* student 7 comes in (a7 = 0), he has nobody to greet;
* student 5 comes in (a5 = 1), he shakes hands with student 7;
* student 2 comes in (a2 = 2), he shakes hands with two students (students 7, 5);
* students 7, 5, 2 form a team and start writing a contest;
* student 1 comes in(a1 = 0), he has no one to greet (everyone is busy with the contest);
* student 6 comes in (a6 = 1), he shakes hands with student 1;
* student 8 comes in (a8 = 2), he shakes hands with two students (students 1, 6);
* student 3 comes in (a3 = 3), he shakes hands with three students (students 1, 6, 8);
* student 4 comes in (a4 = 4), he shakes hands with four students (students 1, 6, 8, 3);
* students 8, 3, 4 form a team and start writing a contest;
* student 9 comes in (a9 = 2), he shakes hands with two students (students 1, 6).
In the third sample from the statement the order of events is restored unambiguously:
* student 1 comes in (a1 = 0), he has no one to greet;
* student 3 comes in (or student 4) (a3 = a4 = 1), he shakes hands with student 1;
* student 2 comes in (a2 = 2), he shakes hands with two students (students 1, 3 (or 4));
* the remaining student 4 (or student 3), must shake one student's hand (a3 = a4 = 1) but it is impossible as there are only two scenarios: either a team formed and he doesn't greet anyone, or he greets all the three present people who work individually. | instruction | 0 | 70,228 | 17 | 140,456 |
Tags: binary search, constructive algorithms, data structures, greedy
Correct Solution:
```
import os
import sys
from io import BytesIO, IOBase
from collections import Counter
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
def gcd(a, b):
if a == 0:
return b
return gcd(b % a, a)
def lcm(a, b):
return (a * b) / gcd(a, b)
def power(x, y, p):
res = 1
x = x % p
if (x == 0):
return 0
while (y > 0):
if ((y & 1) == 1):
res = (res * x) % p
y = y >> 1
x = (x * x) % p
return res
mod = 998244353
pow2 = [1]
def main():
n=int(input())
a=list(map(int, input().split()))
ans=[]
d={}
for i in range(n):
if a[i] in d:
d[a[i]][0]+=1
d[a[i]][1].append(i)
else:
d[a[i]]=[1,[i]]
curr=0
f=0
for i in range(n):
f=0
if curr in d:
f=1
ans.append(d[curr][1][d[curr][0]-1]+1)
d[curr][0]-=1
if d[curr][0]==0:
del d[curr]
curr+=1
else:
while(curr>0):
curr-=3
if curr in d:
f = 1
ans.append(d[curr][1][d[curr][0] - 1] + 1)
d[curr][0] -= 1
if d[curr][0] == 0:
del d[curr]
curr += 1
if f:
break
if f==0:
break
if f:
print('Possible')
print(*ans)
else:
print('Impossible')
return
if __name__ == "__main__":
main()
``` | output | 1 | 70,228 | 17 | 140,457 |
Provide tags and a correct Python 3 solution for this coding contest problem.
On February, 30th n students came in the Center for Training Olympiad Programmers (CTOP) of the Berland State University. They came one by one, one after another. Each of them went in, and before sitting down at his desk, greeted with those who were present in the room by shaking hands. Each of the students who came in stayed in CTOP until the end of the day and never left.
At any time any three students could join together and start participating in a team contest, which lasted until the end of the day. The team did not distract from the contest for a minute, so when another student came in and greeted those who were present, he did not shake hands with the members of the contest writing team. Each team consisted of exactly three students, and each student could not become a member of more than one team. Different teams could start writing contest at different times.
Given how many present people shook the hands of each student, get a possible order in which the students could have come to CTOP. If such an order does not exist, then print that this is impossible.
Please note that some students could work independently until the end of the day, without participating in a team contest.
Input
The first line contains integer n (1 ≤ n ≤ 2·105) — the number of students who came to CTOP. The next line contains n integers a1, a2, ..., an (0 ≤ ai < n), where ai is the number of students with who the i-th student shook hands.
Output
If the sought order of students exists, print in the first line "Possible" and in the second line print the permutation of the students' numbers defining the order in which the students entered the center. Number i that stands to the left of number j in this permutation means that the i-th student came earlier than the j-th student. If there are multiple answers, print any of them.
If the sought order of students doesn't exist, in a single line print "Impossible".
Examples
Input
5
2 1 3 0 1
Output
Possible
4 5 1 3 2
Input
9
0 2 3 4 1 1 0 2 2
Output
Possible
7 5 2 1 6 8 3 4 9
Input
4
0 2 1 1
Output
Impossible
Note
In the first sample from the statement the order of events could be as follows:
* student 4 comes in (a4 = 0), he has no one to greet;
* student 5 comes in (a5 = 1), he shakes hands with student 4;
* student 1 comes in (a1 = 2), he shakes hands with two students (students 4, 5);
* student 3 comes in (a3 = 3), he shakes hands with three students (students 4, 5, 1);
* students 4, 5, 3 form a team and start writing a contest;
* student 2 comes in (a2 = 1), he shakes hands with one student (number 1).
In the second sample from the statement the order of events could be as follows:
* student 7 comes in (a7 = 0), he has nobody to greet;
* student 5 comes in (a5 = 1), he shakes hands with student 7;
* student 2 comes in (a2 = 2), he shakes hands with two students (students 7, 5);
* students 7, 5, 2 form a team and start writing a contest;
* student 1 comes in(a1 = 0), he has no one to greet (everyone is busy with the contest);
* student 6 comes in (a6 = 1), he shakes hands with student 1;
* student 8 comes in (a8 = 2), he shakes hands with two students (students 1, 6);
* student 3 comes in (a3 = 3), he shakes hands with three students (students 1, 6, 8);
* student 4 comes in (a4 = 4), he shakes hands with four students (students 1, 6, 8, 3);
* students 8, 3, 4 form a team and start writing a contest;
* student 9 comes in (a9 = 2), he shakes hands with two students (students 1, 6).
In the third sample from the statement the order of events is restored unambiguously:
* student 1 comes in (a1 = 0), he has no one to greet;
* student 3 comes in (or student 4) (a3 = a4 = 1), he shakes hands with student 1;
* student 2 comes in (a2 = 2), he shakes hands with two students (students 1, 3 (or 4));
* the remaining student 4 (or student 3), must shake one student's hand (a3 = a4 = 1) but it is impossible as there are only two scenarios: either a team formed and he doesn't greet anyone, or he greets all the three present people who work individually. | instruction | 0 | 70,229 | 17 | 140,458 |
Tags: binary search, constructive algorithms, data structures, greedy
Correct Solution:
```
# ---------------------------iye ha aam zindegi---------------------------------------------
import math
import random
import heapq,bisect
import sys
from collections import deque, defaultdict
from fractions import Fraction
import sys
import threading
from collections import defaultdict
threading.stack_size(10**8)
mod = 10 ** 9 + 7
mod1 = 998244353
# ------------------------------warmup----------------------------
import os
import sys
from io import BytesIO, IOBase
sys.setrecursionlimit(300000)
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# -------------------game starts now----------------------------------------------------import math
class TreeNode:
def __init__(self, k, v):
self.key = k
self.value = v
self.left = None
self.right = None
self.parent = None
self.height = 1
self.num_left = 1
self.num_total = 1
class AvlTree:
def __init__(self):
self._tree = None
def add(self, k, v):
if not self._tree:
self._tree = TreeNode(k, v)
return
node = self._add(k, v)
if node:
self._rebalance(node)
def _add(self, k, v):
node = self._tree
while node:
if k < node.key:
if node.left:
node = node.left
else:
node.left = TreeNode(k, v)
node.left.parent = node
return node.left
elif node.key < k:
if node.right:
node = node.right
else:
node.right = TreeNode(k, v)
node.right.parent = node
return node.right
else:
node.value = v
return
@staticmethod
def get_height(x):
return x.height if x else 0
@staticmethod
def get_num_total(x):
return x.num_total if x else 0
def _rebalance(self, node):
n = node
while n:
lh = self.get_height(n.left)
rh = self.get_height(n.right)
n.height = max(lh, rh) + 1
balance_factor = lh - rh
n.num_total = 1 + self.get_num_total(n.left) + self.get_num_total(n.right)
n.num_left = 1 + self.get_num_total(n.left)
if balance_factor > 1:
if self.get_height(n.left.left) < self.get_height(n.left.right):
self._rotate_left(n.left)
self._rotate_right(n)
elif balance_factor < -1:
if self.get_height(n.right.right) < self.get_height(n.right.left):
self._rotate_right(n.right)
self._rotate_left(n)
else:
n = n.parent
def _remove_one(self, node):
"""
Side effect!!! Changes node. Node should have exactly one child
"""
replacement = node.left or node.right
if node.parent:
if AvlTree._is_left(node):
node.parent.left = replacement
else:
node.parent.right = replacement
replacement.parent = node.parent
node.parent = None
else:
self._tree = replacement
replacement.parent = None
node.left = None
node.right = None
node.parent = None
self._rebalance(replacement)
def _remove_leaf(self, node):
if node.parent:
if AvlTree._is_left(node):
node.parent.left = None
else:
node.parent.right = None
self._rebalance(node.parent)
else:
self._tree = None
node.parent = None
node.left = None
node.right = None
def remove(self, k):
node = self._get_node(k)
if not node:
return
if AvlTree._is_leaf(node):
self._remove_leaf(node)
return
if node.left and node.right:
nxt = AvlTree._get_next(node)
node.key = nxt.key
node.value = nxt.value
if self._is_leaf(nxt):
self._remove_leaf(nxt)
else:
self._remove_one(nxt)
self._rebalance(node)
else:
self._remove_one(node)
def get(self, k):
node = self._get_node(k)
return node.value if node else -1
def _get_node(self, k):
if not self._tree:
return None
node = self._tree
while node:
if k < node.key:
node = node.left
elif node.key < k:
node = node.right
else:
return node
return None
def get_at(self, pos):
x = pos + 1
node = self._tree
while node:
if x < node.num_left:
node = node.left
elif node.num_left < x:
x -= node.num_left
node = node.right
else:
return (node.key, node.value)
raise IndexError("Out of ranges")
@staticmethod
def _is_left(node):
return node.parent.left and node.parent.left == node
@staticmethod
def _is_leaf(node):
return node.left is None and node.right is None
def _rotate_right(self, node):
if not node.parent:
self._tree = node.left
node.left.parent = None
elif AvlTree._is_left(node):
node.parent.left = node.left
node.left.parent = node.parent
else:
node.parent.right = node.left
node.left.parent = node.parent
bk = node.left.right
node.left.right = node
node.parent = node.left
node.left = bk
if bk:
bk.parent = node
node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
node.num_left = 1 + self.get_num_total(node.left)
def _rotate_left(self, node):
if not node.parent:
self._tree = node.right
node.right.parent = None
elif AvlTree._is_left(node):
node.parent.left = node.right
node.right.parent = node.parent
else:
node.parent.right = node.right
node.right.parent = node.parent
bk = node.right.left
node.right.left = node
node.parent = node.right
node.right = bk
if bk:
bk.parent = node
node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
node.num_left = 1 + self.get_num_total(node.left)
@staticmethod
def _get_next(node):
if not node.right:
return node.parent
n = node.right
while n.left:
n = n.left
return n
# -----------------------------------------------binary seacrh tree---------------------------------------
class SegmentTree1:
def __init__(self, data, default=2**51, func=lambda a, b: a & b):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
# -------------------game starts now----------------------------------------------------import math
class SegmentTree:
def __init__(self, data, default=0, func=lambda a, b: max(a , b)):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
# -------------------------------iye ha chutiya zindegi-------------------------------------
class Factorial:
def __init__(self, MOD):
self.MOD = MOD
self.factorials = [1, 1]
self.invModulos = [0, 1]
self.invFactorial_ = [1, 1]
def calc(self, n):
if n <= -1:
print("Invalid argument to calculate n!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.factorials):
return self.factorials[n]
nextArr = [0] * (n + 1 - len(self.factorials))
initialI = len(self.factorials)
prev = self.factorials[-1]
m = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = prev * i % m
self.factorials += nextArr
return self.factorials[n]
def inv(self, n):
if n <= -1:
print("Invalid argument to calculate n^(-1)")
print("n must be non-negative value. But the argument was " + str(n))
exit()
p = self.MOD
pi = n % p
if pi < len(self.invModulos):
return self.invModulos[pi]
nextArr = [0] * (n + 1 - len(self.invModulos))
initialI = len(self.invModulos)
for i in range(initialI, min(p, n + 1)):
next = -self.invModulos[p % i] * (p // i) % p
self.invModulos.append(next)
return self.invModulos[pi]
def invFactorial(self, n):
if n <= -1:
print("Invalid argument to calculate (n^(-1))!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.invFactorial_):
return self.invFactorial_[n]
self.inv(n) # To make sure already calculated n^-1
nextArr = [0] * (n + 1 - len(self.invFactorial_))
initialI = len(self.invFactorial_)
prev = self.invFactorial_[-1]
p = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = (prev * self.invModulos[i % p]) % p
self.invFactorial_ += nextArr
return self.invFactorial_[n]
class Combination:
def __init__(self, MOD):
self.MOD = MOD
self.factorial = Factorial(MOD)
def ncr(self, n, k):
if k < 0 or n < k:
return 0
k = min(k, n - k)
f = self.factorial
return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD
# --------------------------------------iye ha combinations ka zindegi---------------------------------
def powm(a, n, m):
if a == 1 or n == 0:
return 1
if n % 2 == 0:
s = powm(a, n // 2, m)
return s * s % m
else:
return a * powm(a, n - 1, m) % m
# --------------------------------------iye ha power ka zindegi---------------------------------
def sort_list(list1, list2):
zipped_pairs = zip(list2, list1)
z = [x for _, x in sorted(zipped_pairs)]
return z
# --------------------------------------------------product----------------------------------------
def product(l):
por = 1
for i in range(len(l)):
por *= l[i]
return por
# --------------------------------------------------binary----------------------------------------
def binarySearchCount(arr, n, key):
left = 0
right = n - 1
count = 0
while (left <= right):
mid = int((right + left) / 2)
# Check if middle element is
# less than or equal to key
if (arr[mid] < key):
count = mid + 1
left = mid + 1
# If key is smaller, ignore right half
else:
right = mid - 1
return count
# --------------------------------------------------binary----------------------------------------
def countdig(n):
c = 0
while (n > 0):
n //= 10
c += 1
return c
def binary(x, length):
y = bin(x)[2:]
return y if len(y) >= length else "0" * (length - len(y)) + y
def countGreater(arr, n, k):
l = 0
r = n - 1
# Stores the index of the left most element
# from the array which is greater than k
leftGreater = n
# Finds number of elements greater than k
while (l <= r):
m = int(l + (r - l) / 2)
if (arr[m] >= k):
leftGreater = m
r = m - 1
# If mid element is less than
# or equal to k update l
else:
l = m + 1
# Return the count of elements
# greater than k
return (n - leftGreater)
# --------------------------------------------------binary------------------------------------
n=int(input())
l=list(map(int,input().split()))
d=defaultdict(int)
ind=defaultdict(list)
for i in range(n):
ind[l[i]].append(i)
d[l[i]]+=1
ans=[]
s=0
while(True):
while(len(ind[s])==0):
s-=3
if s<0:
break
if s<0:
break
else:
ans.append(ind[s][-1]+1)
ind[s].pop()
s+=1
if len(ans)==n:
print("Possible")
print(*ans,sep=" ")
else:
print("Impossible")
``` | output | 1 | 70,229 | 17 | 140,459 |
Provide tags and a correct Python 3 solution for this coding contest problem.
On February, 30th n students came in the Center for Training Olympiad Programmers (CTOP) of the Berland State University. They came one by one, one after another. Each of them went in, and before sitting down at his desk, greeted with those who were present in the room by shaking hands. Each of the students who came in stayed in CTOP until the end of the day and never left.
At any time any three students could join together and start participating in a team contest, which lasted until the end of the day. The team did not distract from the contest for a minute, so when another student came in and greeted those who were present, he did not shake hands with the members of the contest writing team. Each team consisted of exactly three students, and each student could not become a member of more than one team. Different teams could start writing contest at different times.
Given how many present people shook the hands of each student, get a possible order in which the students could have come to CTOP. If such an order does not exist, then print that this is impossible.
Please note that some students could work independently until the end of the day, without participating in a team contest.
Input
The first line contains integer n (1 ≤ n ≤ 2·105) — the number of students who came to CTOP. The next line contains n integers a1, a2, ..., an (0 ≤ ai < n), where ai is the number of students with who the i-th student shook hands.
Output
If the sought order of students exists, print in the first line "Possible" and in the second line print the permutation of the students' numbers defining the order in which the students entered the center. Number i that stands to the left of number j in this permutation means that the i-th student came earlier than the j-th student. If there are multiple answers, print any of them.
If the sought order of students doesn't exist, in a single line print "Impossible".
Examples
Input
5
2 1 3 0 1
Output
Possible
4 5 1 3 2
Input
9
0 2 3 4 1 1 0 2 2
Output
Possible
7 5 2 1 6 8 3 4 9
Input
4
0 2 1 1
Output
Impossible
Note
In the first sample from the statement the order of events could be as follows:
* student 4 comes in (a4 = 0), he has no one to greet;
* student 5 comes in (a5 = 1), he shakes hands with student 4;
* student 1 comes in (a1 = 2), he shakes hands with two students (students 4, 5);
* student 3 comes in (a3 = 3), he shakes hands with three students (students 4, 5, 1);
* students 4, 5, 3 form a team and start writing a contest;
* student 2 comes in (a2 = 1), he shakes hands with one student (number 1).
In the second sample from the statement the order of events could be as follows:
* student 7 comes in (a7 = 0), he has nobody to greet;
* student 5 comes in (a5 = 1), he shakes hands with student 7;
* student 2 comes in (a2 = 2), he shakes hands with two students (students 7, 5);
* students 7, 5, 2 form a team and start writing a contest;
* student 1 comes in(a1 = 0), he has no one to greet (everyone is busy with the contest);
* student 6 comes in (a6 = 1), he shakes hands with student 1;
* student 8 comes in (a8 = 2), he shakes hands with two students (students 1, 6);
* student 3 comes in (a3 = 3), he shakes hands with three students (students 1, 6, 8);
* student 4 comes in (a4 = 4), he shakes hands with four students (students 1, 6, 8, 3);
* students 8, 3, 4 form a team and start writing a contest;
* student 9 comes in (a9 = 2), he shakes hands with two students (students 1, 6).
In the third sample from the statement the order of events is restored unambiguously:
* student 1 comes in (a1 = 0), he has no one to greet;
* student 3 comes in (or student 4) (a3 = a4 = 1), he shakes hands with student 1;
* student 2 comes in (a2 = 2), he shakes hands with two students (students 1, 3 (or 4));
* the remaining student 4 (or student 3), must shake one student's hand (a3 = a4 = 1) but it is impossible as there are only two scenarios: either a team formed and he doesn't greet anyone, or he greets all the three present people who work individually. | instruction | 0 | 70,230 | 17 | 140,460 |
Tags: binary search, constructive algorithms, data structures, greedy
Correct Solution:
```
n=int(input())
c=[[] for i in range(n)]
[c[int(x)].append(i+1) for i,x in enumerate(input().split())]
s=0;r=[]
for i in range(n):
while len(c[s])==0 and s>=0:
s-=3
if s<0:
print('Impossible')
break
else:
r+=[c[s].pop()]
s+=1
else:
print('Possible')
print(*r)
``` | output | 1 | 70,230 | 17 | 140,461 |
Provide tags and a correct Python 3 solution for this coding contest problem.
On February, 30th n students came in the Center for Training Olympiad Programmers (CTOP) of the Berland State University. They came one by one, one after another. Each of them went in, and before sitting down at his desk, greeted with those who were present in the room by shaking hands. Each of the students who came in stayed in CTOP until the end of the day and never left.
At any time any three students could join together and start participating in a team contest, which lasted until the end of the day. The team did not distract from the contest for a minute, so when another student came in and greeted those who were present, he did not shake hands with the members of the contest writing team. Each team consisted of exactly three students, and each student could not become a member of more than one team. Different teams could start writing contest at different times.
Given how many present people shook the hands of each student, get a possible order in which the students could have come to CTOP. If such an order does not exist, then print that this is impossible.
Please note that some students could work independently until the end of the day, without participating in a team contest.
Input
The first line contains integer n (1 ≤ n ≤ 2·105) — the number of students who came to CTOP. The next line contains n integers a1, a2, ..., an (0 ≤ ai < n), where ai is the number of students with who the i-th student shook hands.
Output
If the sought order of students exists, print in the first line "Possible" and in the second line print the permutation of the students' numbers defining the order in which the students entered the center. Number i that stands to the left of number j in this permutation means that the i-th student came earlier than the j-th student. If there are multiple answers, print any of them.
If the sought order of students doesn't exist, in a single line print "Impossible".
Examples
Input
5
2 1 3 0 1
Output
Possible
4 5 1 3 2
Input
9
0 2 3 4 1 1 0 2 2
Output
Possible
7 5 2 1 6 8 3 4 9
Input
4
0 2 1 1
Output
Impossible
Note
In the first sample from the statement the order of events could be as follows:
* student 4 comes in (a4 = 0), he has no one to greet;
* student 5 comes in (a5 = 1), he shakes hands with student 4;
* student 1 comes in (a1 = 2), he shakes hands with two students (students 4, 5);
* student 3 comes in (a3 = 3), he shakes hands with three students (students 4, 5, 1);
* students 4, 5, 3 form a team and start writing a contest;
* student 2 comes in (a2 = 1), he shakes hands with one student (number 1).
In the second sample from the statement the order of events could be as follows:
* student 7 comes in (a7 = 0), he has nobody to greet;
* student 5 comes in (a5 = 1), he shakes hands with student 7;
* student 2 comes in (a2 = 2), he shakes hands with two students (students 7, 5);
* students 7, 5, 2 form a team and start writing a contest;
* student 1 comes in(a1 = 0), he has no one to greet (everyone is busy with the contest);
* student 6 comes in (a6 = 1), he shakes hands with student 1;
* student 8 comes in (a8 = 2), he shakes hands with two students (students 1, 6);
* student 3 comes in (a3 = 3), he shakes hands with three students (students 1, 6, 8);
* student 4 comes in (a4 = 4), he shakes hands with four students (students 1, 6, 8, 3);
* students 8, 3, 4 form a team and start writing a contest;
* student 9 comes in (a9 = 2), he shakes hands with two students (students 1, 6).
In the third sample from the statement the order of events is restored unambiguously:
* student 1 comes in (a1 = 0), he has no one to greet;
* student 3 comes in (or student 4) (a3 = a4 = 1), he shakes hands with student 1;
* student 2 comes in (a2 = 2), he shakes hands with two students (students 1, 3 (or 4));
* the remaining student 4 (or student 3), must shake one student's hand (a3 = a4 = 1) but it is impossible as there are only two scenarios: either a team formed and he doesn't greet anyone, or he greets all the three present people who work individually. | instruction | 0 | 70,231 | 17 | 140,462 |
Tags: binary search, constructive algorithms, data structures, greedy
Correct Solution:
```
#from bisect import bisect_left as bl #c++ lowerbound bl(array,element)
#from bisect import bisect_right as br #c++ upperbound br(array,element)
#from __future__ import print_function, division #while using python2
# from itertools import accumulate
from collections import defaultdict, Counter
def modinv(n,p):
return pow(n,p-2,p)
def main():
#sys.stdin = open('input.txt', 'r')
#sys.stdout = open('output.txt', 'w')
n = int(input())
arr = [int(x) for x in input().split()]
handshakes_vs_ind = defaultdict(lambda : [])
for i in range(n):
handshakes_vs_ind[arr[i]].append(i+1)
# print(dict(handshakes_vs_ind))
ct = Counter(arr)
possible = True
order = []
i = 1
c = 0
while i <= n:
# print("c = ", c)
if ct[c] > 0:
ct[c] -= 1
order.append(handshakes_vs_ind[c].pop())
i += 1
c += 1
else:
while c >= 0 and ct[c] <= 0:
c -= 3
if ct[c] == 0:
possible = False
break
if not possible:
print("Impossible")
else:
print("Possible")
print(*order)
#------------------ Python 2 and 3 footer by Pajenegod and c1729-----------------------------------------
py2 = round(0.5)
if py2:
from future_builtins import ascii, filter, hex, map, oct, zip
range = xrange
import os, sys
from io import IOBase, BytesIO
BUFSIZE = 8192
class FastIO(BytesIO):
newlines = 0
def __init__(self, file):
self._file = file
self._fd = file.fileno()
self.writable = "x" in file.mode or "w" in file.mode
self.write = super(FastIO, self).write if self.writable else None
def _fill(self):
s = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.seek((self.tell(), self.seek(0,2), super(FastIO, self).write(s))[0])
return s
def read(self):
while self._fill(): pass
return super(FastIO,self).read()
def readline(self):
while self.newlines == 0:
s = self._fill(); self.newlines = s.count(b"\n") + (not s)
self.newlines -= 1
return super(FastIO, self).readline()
def flush(self):
if self.writable:
os.write(self._fd, self.getvalue())
self.truncate(0), self.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
if py2:
self.write = self.buffer.write
self.read = self.buffer.read
self.readline = self.buffer.readline
else:
self.write = lambda s:self.buffer.write(s.encode('ascii'))
self.read = lambda:self.buffer.read().decode('ascii')
self.readline = lambda:self.buffer.readline().decode('ascii')
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip('\r\n')
if __name__ == '__main__':
main()
``` | output | 1 | 70,231 | 17 | 140,463 |
Provide tags and a correct Python 3 solution for this coding contest problem.
On February, 30th n students came in the Center for Training Olympiad Programmers (CTOP) of the Berland State University. They came one by one, one after another. Each of them went in, and before sitting down at his desk, greeted with those who were present in the room by shaking hands. Each of the students who came in stayed in CTOP until the end of the day and never left.
At any time any three students could join together and start participating in a team contest, which lasted until the end of the day. The team did not distract from the contest for a minute, so when another student came in and greeted those who were present, he did not shake hands with the members of the contest writing team. Each team consisted of exactly three students, and each student could not become a member of more than one team. Different teams could start writing contest at different times.
Given how many present people shook the hands of each student, get a possible order in which the students could have come to CTOP. If such an order does not exist, then print that this is impossible.
Please note that some students could work independently until the end of the day, without participating in a team contest.
Input
The first line contains integer n (1 ≤ n ≤ 2·105) — the number of students who came to CTOP. The next line contains n integers a1, a2, ..., an (0 ≤ ai < n), where ai is the number of students with who the i-th student shook hands.
Output
If the sought order of students exists, print in the first line "Possible" and in the second line print the permutation of the students' numbers defining the order in which the students entered the center. Number i that stands to the left of number j in this permutation means that the i-th student came earlier than the j-th student. If there are multiple answers, print any of them.
If the sought order of students doesn't exist, in a single line print "Impossible".
Examples
Input
5
2 1 3 0 1
Output
Possible
4 5 1 3 2
Input
9
0 2 3 4 1 1 0 2 2
Output
Possible
7 5 2 1 6 8 3 4 9
Input
4
0 2 1 1
Output
Impossible
Note
In the first sample from the statement the order of events could be as follows:
* student 4 comes in (a4 = 0), he has no one to greet;
* student 5 comes in (a5 = 1), he shakes hands with student 4;
* student 1 comes in (a1 = 2), he shakes hands with two students (students 4, 5);
* student 3 comes in (a3 = 3), he shakes hands with three students (students 4, 5, 1);
* students 4, 5, 3 form a team and start writing a contest;
* student 2 comes in (a2 = 1), he shakes hands with one student (number 1).
In the second sample from the statement the order of events could be as follows:
* student 7 comes in (a7 = 0), he has nobody to greet;
* student 5 comes in (a5 = 1), he shakes hands with student 7;
* student 2 comes in (a2 = 2), he shakes hands with two students (students 7, 5);
* students 7, 5, 2 form a team and start writing a contest;
* student 1 comes in(a1 = 0), he has no one to greet (everyone is busy with the contest);
* student 6 comes in (a6 = 1), he shakes hands with student 1;
* student 8 comes in (a8 = 2), he shakes hands with two students (students 1, 6);
* student 3 comes in (a3 = 3), he shakes hands with three students (students 1, 6, 8);
* student 4 comes in (a4 = 4), he shakes hands with four students (students 1, 6, 8, 3);
* students 8, 3, 4 form a team and start writing a contest;
* student 9 comes in (a9 = 2), he shakes hands with two students (students 1, 6).
In the third sample from the statement the order of events is restored unambiguously:
* student 1 comes in (a1 = 0), he has no one to greet;
* student 3 comes in (or student 4) (a3 = a4 = 1), he shakes hands with student 1;
* student 2 comes in (a2 = 2), he shakes hands with two students (students 1, 3 (or 4));
* the remaining student 4 (or student 3), must shake one student's hand (a3 = a4 = 1) but it is impossible as there are only two scenarios: either a team formed and he doesn't greet anyone, or he greets all the three present people who work individually. | instruction | 0 | 70,232 | 17 | 140,464 |
Tags: binary search, constructive algorithms, data structures, greedy
Correct Solution:
```
import sys
import math
import heapq
import bisect
from collections import Counter
from collections import defaultdict
from io import BytesIO, IOBase
import string
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
import os
self.os = os
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
self.BUFSIZE = 8192
def read(self):
while True:
b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, self.BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, self.BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
self.os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
def get_int():
return int(input())
def get_ints():
return list(map(int, input().split(' ')))
def get_int_grid(n):
return [get_ints() for _ in range(n)]
def get_str():
return input().strip()
def get_strs():
return get_str().split(' ')
def flat_list(arr):
return [item for subarr in arr for item in subarr]
def yes_no(b):
if b:
return "YES"
else:
return "NO"
def binary_search(good, left, right, delta=1, right_true=False):
"""
Performs binary search
----------
Parameters
----------
:param good: Function used to perform the binary search
:param left: Starting value of left limit
:param right: Starting value of the right limit
:param delta: Margin of error, defaults value of 1 for integer binary search
:param right_true: Boolean, for whether the right limit is the true invariant
:return: Returns the most extremal value interval [left, right] which is good function evaluates to True,
alternatively returns False if no such value found
"""
limits = [left, right]
while limits[1] - limits[0] > delta:
if delta == 1:
mid = sum(limits) // 2
else:
mid = sum(limits) / 2
if good(mid):
limits[int(right_true)] = mid
else:
limits[int(~right_true)] = mid
if good(limits[int(right_true)]):
return limits[int(right_true)]
else:
return False
def prefix_sums(a):
p = [0]
for x in a:
p.append(p[-1] + x)
return p
def solve_d():
n = get_int()
arr = get_ints()
d = [[] for _ in range(n)]
for idx, val in enumerate(arr):
d[val].append(idx + 1)
ans = []
i = 0
while n > 0:
if d[i]:
ans.append(d[i].pop())
n -= 1
i += 1
else:
j = i
while j >= 0 and not d[j]:
j -= 3
if j < 0:
break
i = j
if n != 0:
return False
else:
return ans
X = solve_d()
if X:
print("Possible")
print(*X)
else:
print("Impossible")
``` | output | 1 | 70,232 | 17 | 140,465 |
Provide tags and a correct Python 3 solution for this coding contest problem.
On February, 30th n students came in the Center for Training Olympiad Programmers (CTOP) of the Berland State University. They came one by one, one after another. Each of them went in, and before sitting down at his desk, greeted with those who were present in the room by shaking hands. Each of the students who came in stayed in CTOP until the end of the day and never left.
At any time any three students could join together and start participating in a team contest, which lasted until the end of the day. The team did not distract from the contest for a minute, so when another student came in and greeted those who were present, he did not shake hands with the members of the contest writing team. Each team consisted of exactly three students, and each student could not become a member of more than one team. Different teams could start writing contest at different times.
Given how many present people shook the hands of each student, get a possible order in which the students could have come to CTOP. If such an order does not exist, then print that this is impossible.
Please note that some students could work independently until the end of the day, without participating in a team contest.
Input
The first line contains integer n (1 ≤ n ≤ 2·105) — the number of students who came to CTOP. The next line contains n integers a1, a2, ..., an (0 ≤ ai < n), where ai is the number of students with who the i-th student shook hands.
Output
If the sought order of students exists, print in the first line "Possible" and in the second line print the permutation of the students' numbers defining the order in which the students entered the center. Number i that stands to the left of number j in this permutation means that the i-th student came earlier than the j-th student. If there are multiple answers, print any of them.
If the sought order of students doesn't exist, in a single line print "Impossible".
Examples
Input
5
2 1 3 0 1
Output
Possible
4 5 1 3 2
Input
9
0 2 3 4 1 1 0 2 2
Output
Possible
7 5 2 1 6 8 3 4 9
Input
4
0 2 1 1
Output
Impossible
Note
In the first sample from the statement the order of events could be as follows:
* student 4 comes in (a4 = 0), he has no one to greet;
* student 5 comes in (a5 = 1), he shakes hands with student 4;
* student 1 comes in (a1 = 2), he shakes hands with two students (students 4, 5);
* student 3 comes in (a3 = 3), he shakes hands with three students (students 4, 5, 1);
* students 4, 5, 3 form a team and start writing a contest;
* student 2 comes in (a2 = 1), he shakes hands with one student (number 1).
In the second sample from the statement the order of events could be as follows:
* student 7 comes in (a7 = 0), he has nobody to greet;
* student 5 comes in (a5 = 1), he shakes hands with student 7;
* student 2 comes in (a2 = 2), he shakes hands with two students (students 7, 5);
* students 7, 5, 2 form a team and start writing a contest;
* student 1 comes in(a1 = 0), he has no one to greet (everyone is busy with the contest);
* student 6 comes in (a6 = 1), he shakes hands with student 1;
* student 8 comes in (a8 = 2), he shakes hands with two students (students 1, 6);
* student 3 comes in (a3 = 3), he shakes hands with three students (students 1, 6, 8);
* student 4 comes in (a4 = 4), he shakes hands with four students (students 1, 6, 8, 3);
* students 8, 3, 4 form a team and start writing a contest;
* student 9 comes in (a9 = 2), he shakes hands with two students (students 1, 6).
In the third sample from the statement the order of events is restored unambiguously:
* student 1 comes in (a1 = 0), he has no one to greet;
* student 3 comes in (or student 4) (a3 = a4 = 1), he shakes hands with student 1;
* student 2 comes in (a2 = 2), he shakes hands with two students (students 1, 3 (or 4));
* the remaining student 4 (or student 3), must shake one student's hand (a3 = a4 = 1) but it is impossible as there are only two scenarios: either a team formed and he doesn't greet anyone, or he greets all the three present people who work individually. | instruction | 0 | 70,233 | 17 | 140,466 |
Tags: binary search, constructive algorithms, data structures, greedy
Correct Solution:
```
n = int(input())
a = list(map(int, input().split()))
dic = [[] for i in range(n)]
for i, item in enumerate(a, start=1):
dic[item].append(i)
if not dic[0]:
print("Impossible")
exit()
route = [dic[0].pop()]
s = 0
for i in range(1, n):
s += 1
while s >= 0:
if dic[s]:
route.append(dic[s].pop())
break
else:
s -= 3
else:
print("Impossible")
exit()
if len(route) == n:
print("Possible")
print(' '.join(str(i) for i in route))
else:
print("Impossible")
``` | output | 1 | 70,233 | 17 | 140,467 |
Provide tags and a correct Python 3 solution for this coding contest problem.
On February, 30th n students came in the Center for Training Olympiad Programmers (CTOP) of the Berland State University. They came one by one, one after another. Each of them went in, and before sitting down at his desk, greeted with those who were present in the room by shaking hands. Each of the students who came in stayed in CTOP until the end of the day and never left.
At any time any three students could join together and start participating in a team contest, which lasted until the end of the day. The team did not distract from the contest for a minute, so when another student came in and greeted those who were present, he did not shake hands with the members of the contest writing team. Each team consisted of exactly three students, and each student could not become a member of more than one team. Different teams could start writing contest at different times.
Given how many present people shook the hands of each student, get a possible order in which the students could have come to CTOP. If such an order does not exist, then print that this is impossible.
Please note that some students could work independently until the end of the day, without participating in a team contest.
Input
The first line contains integer n (1 ≤ n ≤ 2·105) — the number of students who came to CTOP. The next line contains n integers a1, a2, ..., an (0 ≤ ai < n), where ai is the number of students with who the i-th student shook hands.
Output
If the sought order of students exists, print in the first line "Possible" and in the second line print the permutation of the students' numbers defining the order in which the students entered the center. Number i that stands to the left of number j in this permutation means that the i-th student came earlier than the j-th student. If there are multiple answers, print any of them.
If the sought order of students doesn't exist, in a single line print "Impossible".
Examples
Input
5
2 1 3 0 1
Output
Possible
4 5 1 3 2
Input
9
0 2 3 4 1 1 0 2 2
Output
Possible
7 5 2 1 6 8 3 4 9
Input
4
0 2 1 1
Output
Impossible
Note
In the first sample from the statement the order of events could be as follows:
* student 4 comes in (a4 = 0), he has no one to greet;
* student 5 comes in (a5 = 1), he shakes hands with student 4;
* student 1 comes in (a1 = 2), he shakes hands with two students (students 4, 5);
* student 3 comes in (a3 = 3), he shakes hands with three students (students 4, 5, 1);
* students 4, 5, 3 form a team and start writing a contest;
* student 2 comes in (a2 = 1), he shakes hands with one student (number 1).
In the second sample from the statement the order of events could be as follows:
* student 7 comes in (a7 = 0), he has nobody to greet;
* student 5 comes in (a5 = 1), he shakes hands with student 7;
* student 2 comes in (a2 = 2), he shakes hands with two students (students 7, 5);
* students 7, 5, 2 form a team and start writing a contest;
* student 1 comes in(a1 = 0), he has no one to greet (everyone is busy with the contest);
* student 6 comes in (a6 = 1), he shakes hands with student 1;
* student 8 comes in (a8 = 2), he shakes hands with two students (students 1, 6);
* student 3 comes in (a3 = 3), he shakes hands with three students (students 1, 6, 8);
* student 4 comes in (a4 = 4), he shakes hands with four students (students 1, 6, 8, 3);
* students 8, 3, 4 form a team and start writing a contest;
* student 9 comes in (a9 = 2), he shakes hands with two students (students 1, 6).
In the third sample from the statement the order of events is restored unambiguously:
* student 1 comes in (a1 = 0), he has no one to greet;
* student 3 comes in (or student 4) (a3 = a4 = 1), he shakes hands with student 1;
* student 2 comes in (a2 = 2), he shakes hands with two students (students 1, 3 (or 4));
* the remaining student 4 (or student 3), must shake one student's hand (a3 = a4 = 1) but it is impossible as there are only two scenarios: either a team formed and he doesn't greet anyone, or he greets all the three present people who work individually. | instruction | 0 | 70,234 | 17 | 140,468 |
Tags: binary search, constructive algorithms, data structures, greedy
Correct Solution:
```
from sys import stdin, stdout
from math import floor, gcd, fabs, factorial, fmod, sqrt, inf, log
from collections import defaultdict as dd, deque
from heapq import merge, heapify, heappop, heappush, nsmallest
from bisect import bisect_left as bl, bisect_right as br, bisect
mod = pow(10, 9) + 7
mod2 = 998244353
def inp(): return stdin.readline().strip()
def iinp(): return int(inp())
def out(var, end="\n"): stdout.write(str(var)+"\n")
def outa(*var, end="\n"): stdout.write(' '.join(map(str, var)) + end)
def lmp(): return list(mp())
def mp(): return map(int, inp().split())
def smp(): return map(str, inp().split())
def l1d(n, val=0): return [val for i in range(n)]
def l2d(n, m, val=0): return [l1d(m, val) for j in range(n)]
def remadd(x, y): return 1 if x%y else 0
def ceil(a,b): return (a+b-1)//b
def isprime(x):
if x<=1: return False
if x in (2, 3): return True
if x%2 == 0: return False
for i in range(3, int(sqrt(x))+1, 2):
if x%i == 0: return False
return True
n = iinp()
arr = lmp()
md = dd(int)
for i in arr: md[i]+=1
for i in range(n+1):
if md[i]==0:
break
flg = False
if i>max(arr):
flg = True
del md
md = dd(list)
for i in range(n): md[arr[i]%3].append((arr[i], i))
a, b, c = len(md[0]), len(md[1]), len(md[2])
b -= c
a -= c
if (a, b) not in [(0, 0), (1, 0), (1, 1)]:
flg &= False
if not flg:
print("Impossible")
else:
print("Possible")
md = dd(list)
for i in range(n): md[arr[i]].append(i)
# print(md)
c = 0
i = 0
while(c<n):
if len(md[i])>0:
print(md[i][-1]+1, end=" ")
md[i].pop()
else:
i -= 4
c -= 1
i+=1
c+=1
print()
``` | output | 1 | 70,234 | 17 | 140,469 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
On February, 30th n students came in the Center for Training Olympiad Programmers (CTOP) of the Berland State University. They came one by one, one after another. Each of them went in, and before sitting down at his desk, greeted with those who were present in the room by shaking hands. Each of the students who came in stayed in CTOP until the end of the day and never left.
At any time any three students could join together and start participating in a team contest, which lasted until the end of the day. The team did not distract from the contest for a minute, so when another student came in and greeted those who were present, he did not shake hands with the members of the contest writing team. Each team consisted of exactly three students, and each student could not become a member of more than one team. Different teams could start writing contest at different times.
Given how many present people shook the hands of each student, get a possible order in which the students could have come to CTOP. If such an order does not exist, then print that this is impossible.
Please note that some students could work independently until the end of the day, without participating in a team contest.
Input
The first line contains integer n (1 ≤ n ≤ 2·105) — the number of students who came to CTOP. The next line contains n integers a1, a2, ..., an (0 ≤ ai < n), where ai is the number of students with who the i-th student shook hands.
Output
If the sought order of students exists, print in the first line "Possible" and in the second line print the permutation of the students' numbers defining the order in which the students entered the center. Number i that stands to the left of number j in this permutation means that the i-th student came earlier than the j-th student. If there are multiple answers, print any of them.
If the sought order of students doesn't exist, in a single line print "Impossible".
Examples
Input
5
2 1 3 0 1
Output
Possible
4 5 1 3 2
Input
9
0 2 3 4 1 1 0 2 2
Output
Possible
7 5 2 1 6 8 3 4 9
Input
4
0 2 1 1
Output
Impossible
Note
In the first sample from the statement the order of events could be as follows:
* student 4 comes in (a4 = 0), he has no one to greet;
* student 5 comes in (a5 = 1), he shakes hands with student 4;
* student 1 comes in (a1 = 2), he shakes hands with two students (students 4, 5);
* student 3 comes in (a3 = 3), he shakes hands with three students (students 4, 5, 1);
* students 4, 5, 3 form a team and start writing a contest;
* student 2 comes in (a2 = 1), he shakes hands with one student (number 1).
In the second sample from the statement the order of events could be as follows:
* student 7 comes in (a7 = 0), he has nobody to greet;
* student 5 comes in (a5 = 1), he shakes hands with student 7;
* student 2 comes in (a2 = 2), he shakes hands with two students (students 7, 5);
* students 7, 5, 2 form a team and start writing a contest;
* student 1 comes in(a1 = 0), he has no one to greet (everyone is busy with the contest);
* student 6 comes in (a6 = 1), he shakes hands with student 1;
* student 8 comes in (a8 = 2), he shakes hands with two students (students 1, 6);
* student 3 comes in (a3 = 3), he shakes hands with three students (students 1, 6, 8);
* student 4 comes in (a4 = 4), he shakes hands with four students (students 1, 6, 8, 3);
* students 8, 3, 4 form a team and start writing a contest;
* student 9 comes in (a9 = 2), he shakes hands with two students (students 1, 6).
In the third sample from the statement the order of events is restored unambiguously:
* student 1 comes in (a1 = 0), he has no one to greet;
* student 3 comes in (or student 4) (a3 = a4 = 1), he shakes hands with student 1;
* student 2 comes in (a2 = 2), he shakes hands with two students (students 1, 3 (or 4));
* the remaining student 4 (or student 3), must shake one student's hand (a3 = a4 = 1) but it is impossible as there are only two scenarios: either a team formed and he doesn't greet anyone, or he greets all the three present people who work individually.
Submitted Solution:
```
n = int(input())
d = [[] for i in range(n)]
for i, q in enumerate(input().split(), 1): d[int(q)] += [i]
q = j = 0
t = [0] * n
while j < n and q >= 0:
if d[q]:
t[j] = d[q].pop()
q += 1
j += 1
else: q -= 3
if q < 0: print('Impossible')
else: print('Possible', *t)
``` | instruction | 0 | 70,235 | 17 | 140,470 |
Yes | output | 1 | 70,235 | 17 | 140,471 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
On February, 30th n students came in the Center for Training Olympiad Programmers (CTOP) of the Berland State University. They came one by one, one after another. Each of them went in, and before sitting down at his desk, greeted with those who were present in the room by shaking hands. Each of the students who came in stayed in CTOP until the end of the day and never left.
At any time any three students could join together and start participating in a team contest, which lasted until the end of the day. The team did not distract from the contest for a minute, so when another student came in and greeted those who were present, he did not shake hands with the members of the contest writing team. Each team consisted of exactly three students, and each student could not become a member of more than one team. Different teams could start writing contest at different times.
Given how many present people shook the hands of each student, get a possible order in which the students could have come to CTOP. If such an order does not exist, then print that this is impossible.
Please note that some students could work independently until the end of the day, without participating in a team contest.
Input
The first line contains integer n (1 ≤ n ≤ 2·105) — the number of students who came to CTOP. The next line contains n integers a1, a2, ..., an (0 ≤ ai < n), where ai is the number of students with who the i-th student shook hands.
Output
If the sought order of students exists, print in the first line "Possible" and in the second line print the permutation of the students' numbers defining the order in which the students entered the center. Number i that stands to the left of number j in this permutation means that the i-th student came earlier than the j-th student. If there are multiple answers, print any of them.
If the sought order of students doesn't exist, in a single line print "Impossible".
Examples
Input
5
2 1 3 0 1
Output
Possible
4 5 1 3 2
Input
9
0 2 3 4 1 1 0 2 2
Output
Possible
7 5 2 1 6 8 3 4 9
Input
4
0 2 1 1
Output
Impossible
Note
In the first sample from the statement the order of events could be as follows:
* student 4 comes in (a4 = 0), he has no one to greet;
* student 5 comes in (a5 = 1), he shakes hands with student 4;
* student 1 comes in (a1 = 2), he shakes hands with two students (students 4, 5);
* student 3 comes in (a3 = 3), he shakes hands with three students (students 4, 5, 1);
* students 4, 5, 3 form a team and start writing a contest;
* student 2 comes in (a2 = 1), he shakes hands with one student (number 1).
In the second sample from the statement the order of events could be as follows:
* student 7 comes in (a7 = 0), he has nobody to greet;
* student 5 comes in (a5 = 1), he shakes hands with student 7;
* student 2 comes in (a2 = 2), he shakes hands with two students (students 7, 5);
* students 7, 5, 2 form a team and start writing a contest;
* student 1 comes in(a1 = 0), he has no one to greet (everyone is busy with the contest);
* student 6 comes in (a6 = 1), he shakes hands with student 1;
* student 8 comes in (a8 = 2), he shakes hands with two students (students 1, 6);
* student 3 comes in (a3 = 3), he shakes hands with three students (students 1, 6, 8);
* student 4 comes in (a4 = 4), he shakes hands with four students (students 1, 6, 8, 3);
* students 8, 3, 4 form a team and start writing a contest;
* student 9 comes in (a9 = 2), he shakes hands with two students (students 1, 6).
In the third sample from the statement the order of events is restored unambiguously:
* student 1 comes in (a1 = 0), he has no one to greet;
* student 3 comes in (or student 4) (a3 = a4 = 1), he shakes hands with student 1;
* student 2 comes in (a2 = 2), he shakes hands with two students (students 1, 3 (or 4));
* the remaining student 4 (or student 3), must shake one student's hand (a3 = a4 = 1) but it is impossible as there are only two scenarios: either a team formed and he doesn't greet anyone, or he greets all the three present people who work individually.
Submitted Solution:
```
import sys
from pprint import pprint
n = int(sys.stdin.readline().strip())
a = list(map(int, sys.stdin.readline().strip().split(' ')))
s = [[] for i in range(0, n+1)]
for i, ai in enumerate(a, start=1):
s[ai].append(i)
#pprint(s)
i = 0
q = []
while True:
if len(s[i]) > 0:
# Greedy: Add as many students to the room as possible.
q.append( str( s[i][-1] ) )
i += 1
else:
# Remove a team
if i < 3:
break
s[i-1].pop()
s[i-2].pop()
s[i-3].pop()
i -= 3
if len(q) == n:
print('Possible')
print(' '.join(q) )
else:
print('Impossible')
``` | instruction | 0 | 70,236 | 17 | 140,472 |
Yes | output | 1 | 70,236 | 17 | 140,473 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
On February, 30th n students came in the Center for Training Olympiad Programmers (CTOP) of the Berland State University. They came one by one, one after another. Each of them went in, and before sitting down at his desk, greeted with those who were present in the room by shaking hands. Each of the students who came in stayed in CTOP until the end of the day and never left.
At any time any three students could join together and start participating in a team contest, which lasted until the end of the day. The team did not distract from the contest for a minute, so when another student came in and greeted those who were present, he did not shake hands with the members of the contest writing team. Each team consisted of exactly three students, and each student could not become a member of more than one team. Different teams could start writing contest at different times.
Given how many present people shook the hands of each student, get a possible order in which the students could have come to CTOP. If such an order does not exist, then print that this is impossible.
Please note that some students could work independently until the end of the day, without participating in a team contest.
Input
The first line contains integer n (1 ≤ n ≤ 2·105) — the number of students who came to CTOP. The next line contains n integers a1, a2, ..., an (0 ≤ ai < n), where ai is the number of students with who the i-th student shook hands.
Output
If the sought order of students exists, print in the first line "Possible" and in the second line print the permutation of the students' numbers defining the order in which the students entered the center. Number i that stands to the left of number j in this permutation means that the i-th student came earlier than the j-th student. If there are multiple answers, print any of them.
If the sought order of students doesn't exist, in a single line print "Impossible".
Examples
Input
5
2 1 3 0 1
Output
Possible
4 5 1 3 2
Input
9
0 2 3 4 1 1 0 2 2
Output
Possible
7 5 2 1 6 8 3 4 9
Input
4
0 2 1 1
Output
Impossible
Note
In the first sample from the statement the order of events could be as follows:
* student 4 comes in (a4 = 0), he has no one to greet;
* student 5 comes in (a5 = 1), he shakes hands with student 4;
* student 1 comes in (a1 = 2), he shakes hands with two students (students 4, 5);
* student 3 comes in (a3 = 3), he shakes hands with three students (students 4, 5, 1);
* students 4, 5, 3 form a team and start writing a contest;
* student 2 comes in (a2 = 1), he shakes hands with one student (number 1).
In the second sample from the statement the order of events could be as follows:
* student 7 comes in (a7 = 0), he has nobody to greet;
* student 5 comes in (a5 = 1), he shakes hands with student 7;
* student 2 comes in (a2 = 2), he shakes hands with two students (students 7, 5);
* students 7, 5, 2 form a team and start writing a contest;
* student 1 comes in(a1 = 0), he has no one to greet (everyone is busy with the contest);
* student 6 comes in (a6 = 1), he shakes hands with student 1;
* student 8 comes in (a8 = 2), he shakes hands with two students (students 1, 6);
* student 3 comes in (a3 = 3), he shakes hands with three students (students 1, 6, 8);
* student 4 comes in (a4 = 4), he shakes hands with four students (students 1, 6, 8, 3);
* students 8, 3, 4 form a team and start writing a contest;
* student 9 comes in (a9 = 2), he shakes hands with two students (students 1, 6).
In the third sample from the statement the order of events is restored unambiguously:
* student 1 comes in (a1 = 0), he has no one to greet;
* student 3 comes in (or student 4) (a3 = a4 = 1), he shakes hands with student 1;
* student 2 comes in (a2 = 2), he shakes hands with two students (students 1, 3 (or 4));
* the remaining student 4 (or student 3), must shake one student's hand (a3 = a4 = 1) but it is impossible as there are only two scenarios: either a team formed and he doesn't greet anyone, or he greets all the three present people who work individually.
Submitted Solution:
```
n = int(input())
c = [[] for i in range(n)]
[c[int(x)].append(i + 1) for i, x in enumerate(input().split())]
s = 0; r = []
for i in range(n):
while len(c[s]) == 0 and s >= 0: s -= 3
if s < 0: print('Impossible'); break
r += [c[s].pop()]; s += 1
else: print('Possible\n', *r)
``` | instruction | 0 | 70,237 | 17 | 140,474 |
Yes | output | 1 | 70,237 | 17 | 140,475 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
On February, 30th n students came in the Center for Training Olympiad Programmers (CTOP) of the Berland State University. They came one by one, one after another. Each of them went in, and before sitting down at his desk, greeted with those who were present in the room by shaking hands. Each of the students who came in stayed in CTOP until the end of the day and never left.
At any time any three students could join together and start participating in a team contest, which lasted until the end of the day. The team did not distract from the contest for a minute, so when another student came in and greeted those who were present, he did not shake hands with the members of the contest writing team. Each team consisted of exactly three students, and each student could not become a member of more than one team. Different teams could start writing contest at different times.
Given how many present people shook the hands of each student, get a possible order in which the students could have come to CTOP. If such an order does not exist, then print that this is impossible.
Please note that some students could work independently until the end of the day, without participating in a team contest.
Input
The first line contains integer n (1 ≤ n ≤ 2·105) — the number of students who came to CTOP. The next line contains n integers a1, a2, ..., an (0 ≤ ai < n), where ai is the number of students with who the i-th student shook hands.
Output
If the sought order of students exists, print in the first line "Possible" and in the second line print the permutation of the students' numbers defining the order in which the students entered the center. Number i that stands to the left of number j in this permutation means that the i-th student came earlier than the j-th student. If there are multiple answers, print any of them.
If the sought order of students doesn't exist, in a single line print "Impossible".
Examples
Input
5
2 1 3 0 1
Output
Possible
4 5 1 3 2
Input
9
0 2 3 4 1 1 0 2 2
Output
Possible
7 5 2 1 6 8 3 4 9
Input
4
0 2 1 1
Output
Impossible
Note
In the first sample from the statement the order of events could be as follows:
* student 4 comes in (a4 = 0), he has no one to greet;
* student 5 comes in (a5 = 1), he shakes hands with student 4;
* student 1 comes in (a1 = 2), he shakes hands with two students (students 4, 5);
* student 3 comes in (a3 = 3), he shakes hands with three students (students 4, 5, 1);
* students 4, 5, 3 form a team and start writing a contest;
* student 2 comes in (a2 = 1), he shakes hands with one student (number 1).
In the second sample from the statement the order of events could be as follows:
* student 7 comes in (a7 = 0), he has nobody to greet;
* student 5 comes in (a5 = 1), he shakes hands with student 7;
* student 2 comes in (a2 = 2), he shakes hands with two students (students 7, 5);
* students 7, 5, 2 form a team and start writing a contest;
* student 1 comes in(a1 = 0), he has no one to greet (everyone is busy with the contest);
* student 6 comes in (a6 = 1), he shakes hands with student 1;
* student 8 comes in (a8 = 2), he shakes hands with two students (students 1, 6);
* student 3 comes in (a3 = 3), he shakes hands with three students (students 1, 6, 8);
* student 4 comes in (a4 = 4), he shakes hands with four students (students 1, 6, 8, 3);
* students 8, 3, 4 form a team and start writing a contest;
* student 9 comes in (a9 = 2), he shakes hands with two students (students 1, 6).
In the third sample from the statement the order of events is restored unambiguously:
* student 1 comes in (a1 = 0), he has no one to greet;
* student 3 comes in (or student 4) (a3 = a4 = 1), he shakes hands with student 1;
* student 2 comes in (a2 = 2), he shakes hands with two students (students 1, 3 (or 4));
* the remaining student 4 (or student 3), must shake one student's hand (a3 = a4 = 1) but it is impossible as there are only two scenarios: either a team formed and he doesn't greet anyone, or he greets all the three present people who work individually.
Submitted Solution:
```
import sys
import math
import heapq
import bisect
from collections import Counter
from collections import defaultdict
from io import BytesIO, IOBase
import string
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
import os
self.os = os
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
self.BUFSIZE = 8192
def read(self):
while True:
b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, self.BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, self.BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
self.os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
def get_int():
return int(input())
def get_ints():
return list(map(int, input().split(' ')))
def get_int_grid(n):
return [get_ints() for _ in range(n)]
def get_str():
return input().strip()
def get_strs():
return get_str().split(' ')
def flat_list(arr):
return [item for subarr in arr for item in subarr]
def yes_no(b):
if b:
return "YES"
else:
return "NO"
def binary_search(good, left, right, delta=1, right_true=False):
"""
Performs binary search
----------
Parameters
----------
:param good: Function used to perform the binary search
:param left: Starting value of left limit
:param right: Starting value of the right limit
:param delta: Margin of error, defaults value of 1 for integer binary search
:param right_true: Boolean, for whether the right limit is the true invariant
:return: Returns the most extremal value interval [left, right] which is good function evaluates to True,
alternatively returns False if no such value found
"""
limits = [left, right]
while limits[1] - limits[0] > delta:
if delta == 1:
mid = sum(limits) // 2
else:
mid = sum(limits) / 2
if good(mid):
limits[int(right_true)] = mid
else:
limits[int(~right_true)] = mid
if good(limits[int(right_true)]):
return limits[int(right_true)]
else:
return False
def prefix_sums(a):
p = [0]
for x in a:
p.append(p[-1] + x)
return p
def solve_d():
n = get_int()
arr = get_ints()
d = [[] for _ in range(n)]
for idx, val in enumerate(arr):
d[val].append(idx + 1)
ans = []
i = 0
while n > 0:
if len(d[i]) > 0:
ans.append(d[i].pop())
n -= 1
i += 1
else:
j = i
while j >= 0 and not d[j]:
j -= 3
if j < 0:
break
i = j
if n != 0:
return False
else:
return ans
X = solve_d()
if X:
print("Possible")
print(*X)
else:
print("Impossible")
``` | instruction | 0 | 70,238 | 17 | 140,476 |
Yes | output | 1 | 70,238 | 17 | 140,477 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
On February, 30th n students came in the Center for Training Olympiad Programmers (CTOP) of the Berland State University. They came one by one, one after another. Each of them went in, and before sitting down at his desk, greeted with those who were present in the room by shaking hands. Each of the students who came in stayed in CTOP until the end of the day and never left.
At any time any three students could join together and start participating in a team contest, which lasted until the end of the day. The team did not distract from the contest for a minute, so when another student came in and greeted those who were present, he did not shake hands with the members of the contest writing team. Each team consisted of exactly three students, and each student could not become a member of more than one team. Different teams could start writing contest at different times.
Given how many present people shook the hands of each student, get a possible order in which the students could have come to CTOP. If such an order does not exist, then print that this is impossible.
Please note that some students could work independently until the end of the day, without participating in a team contest.
Input
The first line contains integer n (1 ≤ n ≤ 2·105) — the number of students who came to CTOP. The next line contains n integers a1, a2, ..., an (0 ≤ ai < n), where ai is the number of students with who the i-th student shook hands.
Output
If the sought order of students exists, print in the first line "Possible" and in the second line print the permutation of the students' numbers defining the order in which the students entered the center. Number i that stands to the left of number j in this permutation means that the i-th student came earlier than the j-th student. If there are multiple answers, print any of them.
If the sought order of students doesn't exist, in a single line print "Impossible".
Examples
Input
5
2 1 3 0 1
Output
Possible
4 5 1 3 2
Input
9
0 2 3 4 1 1 0 2 2
Output
Possible
7 5 2 1 6 8 3 4 9
Input
4
0 2 1 1
Output
Impossible
Note
In the first sample from the statement the order of events could be as follows:
* student 4 comes in (a4 = 0), he has no one to greet;
* student 5 comes in (a5 = 1), he shakes hands with student 4;
* student 1 comes in (a1 = 2), he shakes hands with two students (students 4, 5);
* student 3 comes in (a3 = 3), he shakes hands with three students (students 4, 5, 1);
* students 4, 5, 3 form a team and start writing a contest;
* student 2 comes in (a2 = 1), he shakes hands with one student (number 1).
In the second sample from the statement the order of events could be as follows:
* student 7 comes in (a7 = 0), he has nobody to greet;
* student 5 comes in (a5 = 1), he shakes hands with student 7;
* student 2 comes in (a2 = 2), he shakes hands with two students (students 7, 5);
* students 7, 5, 2 form a team and start writing a contest;
* student 1 comes in(a1 = 0), he has no one to greet (everyone is busy with the contest);
* student 6 comes in (a6 = 1), he shakes hands with student 1;
* student 8 comes in (a8 = 2), he shakes hands with two students (students 1, 6);
* student 3 comes in (a3 = 3), he shakes hands with three students (students 1, 6, 8);
* student 4 comes in (a4 = 4), he shakes hands with four students (students 1, 6, 8, 3);
* students 8, 3, 4 form a team and start writing a contest;
* student 9 comes in (a9 = 2), he shakes hands with two students (students 1, 6).
In the third sample from the statement the order of events is restored unambiguously:
* student 1 comes in (a1 = 0), he has no one to greet;
* student 3 comes in (or student 4) (a3 = a4 = 1), he shakes hands with student 1;
* student 2 comes in (a2 = 2), he shakes hands with two students (students 1, 3 (or 4));
* the remaining student 4 (or student 3), must shake one student's hand (a3 = a4 = 1) but it is impossible as there are only two scenarios: either a team formed and he doesn't greet anyone, or he greets all the three present people who work individually.
Submitted Solution:
```
n = int(input())
a = [[ ] for i in range(n)]
for i, x in enumerate(map(int, input().split())):
a[x].append(i)
cur = 0
result = [ ]
for i in range(n):
if cur >= 3 and a[cur - 3]:
result.append(str(a[cur - 3].pop() + 1))
cur -= 2
elif a[cur]:
result.append(str(a[cur].pop() + 1))
cur += 1
else:
print("Impossible")
break
else:
print("Possible")
print(' '.join(result))
``` | instruction | 0 | 70,239 | 17 | 140,478 |
No | output | 1 | 70,239 | 17 | 140,479 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
On February, 30th n students came in the Center for Training Olympiad Programmers (CTOP) of the Berland State University. They came one by one, one after another. Each of them went in, and before sitting down at his desk, greeted with those who were present in the room by shaking hands. Each of the students who came in stayed in CTOP until the end of the day and never left.
At any time any three students could join together and start participating in a team contest, which lasted until the end of the day. The team did not distract from the contest for a minute, so when another student came in and greeted those who were present, he did not shake hands with the members of the contest writing team. Each team consisted of exactly three students, and each student could not become a member of more than one team. Different teams could start writing contest at different times.
Given how many present people shook the hands of each student, get a possible order in which the students could have come to CTOP. If such an order does not exist, then print that this is impossible.
Please note that some students could work independently until the end of the day, without participating in a team contest.
Input
The first line contains integer n (1 ≤ n ≤ 2·105) — the number of students who came to CTOP. The next line contains n integers a1, a2, ..., an (0 ≤ ai < n), where ai is the number of students with who the i-th student shook hands.
Output
If the sought order of students exists, print in the first line "Possible" and in the second line print the permutation of the students' numbers defining the order in which the students entered the center. Number i that stands to the left of number j in this permutation means that the i-th student came earlier than the j-th student. If there are multiple answers, print any of them.
If the sought order of students doesn't exist, in a single line print "Impossible".
Examples
Input
5
2 1 3 0 1
Output
Possible
4 5 1 3 2
Input
9
0 2 3 4 1 1 0 2 2
Output
Possible
7 5 2 1 6 8 3 4 9
Input
4
0 2 1 1
Output
Impossible
Note
In the first sample from the statement the order of events could be as follows:
* student 4 comes in (a4 = 0), he has no one to greet;
* student 5 comes in (a5 = 1), he shakes hands with student 4;
* student 1 comes in (a1 = 2), he shakes hands with two students (students 4, 5);
* student 3 comes in (a3 = 3), he shakes hands with three students (students 4, 5, 1);
* students 4, 5, 3 form a team and start writing a contest;
* student 2 comes in (a2 = 1), he shakes hands with one student (number 1).
In the second sample from the statement the order of events could be as follows:
* student 7 comes in (a7 = 0), he has nobody to greet;
* student 5 comes in (a5 = 1), he shakes hands with student 7;
* student 2 comes in (a2 = 2), he shakes hands with two students (students 7, 5);
* students 7, 5, 2 form a team and start writing a contest;
* student 1 comes in(a1 = 0), he has no one to greet (everyone is busy with the contest);
* student 6 comes in (a6 = 1), he shakes hands with student 1;
* student 8 comes in (a8 = 2), he shakes hands with two students (students 1, 6);
* student 3 comes in (a3 = 3), he shakes hands with three students (students 1, 6, 8);
* student 4 comes in (a4 = 4), he shakes hands with four students (students 1, 6, 8, 3);
* students 8, 3, 4 form a team and start writing a contest;
* student 9 comes in (a9 = 2), he shakes hands with two students (students 1, 6).
In the third sample from the statement the order of events is restored unambiguously:
* student 1 comes in (a1 = 0), he has no one to greet;
* student 3 comes in (or student 4) (a3 = a4 = 1), he shakes hands with student 1;
* student 2 comes in (a2 = 2), he shakes hands with two students (students 1, 3 (or 4));
* the remaining student 4 (or student 3), must shake one student's hand (a3 = a4 = 1) but it is impossible as there are only two scenarios: either a team formed and he doesn't greet anyone, or he greets all the three present people who work individually.
Submitted Solution:
```
import sys, threading
threading.stack_size(2**27)
sys.setrecursionlimit(2*10**5 + 100)
def boy_next_door(dic, current, route):
for i in range(current + 1, -1, -3):
if dic[i]:
route.append(dic[i].pop())
route = boy_next_door(dic, i, route)
return route
def main():
n = int(input())
a = list(map(int, input().split()))
dic = [[] for i in range(n)]
for i, item in enumerate(a, start=1):
dic[item].append(i)
if not dic[0]:
print("Impossible")
exit()
route = [dic[0].pop()]
route = boy_next_door(dic, 0, route)
if len(route) == n:
print("Possible")
print(' '.join(str(i) for i in route))
else:
print("Impossible")
t = threading.Thread(target=main)
t.start()
t.join()
``` | instruction | 0 | 70,240 | 17 | 140,480 |
No | output | 1 | 70,240 | 17 | 140,481 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
On February, 30th n students came in the Center for Training Olympiad Programmers (CTOP) of the Berland State University. They came one by one, one after another. Each of them went in, and before sitting down at his desk, greeted with those who were present in the room by shaking hands. Each of the students who came in stayed in CTOP until the end of the day and never left.
At any time any three students could join together and start participating in a team contest, which lasted until the end of the day. The team did not distract from the contest for a minute, so when another student came in and greeted those who were present, he did not shake hands with the members of the contest writing team. Each team consisted of exactly three students, and each student could not become a member of more than one team. Different teams could start writing contest at different times.
Given how many present people shook the hands of each student, get a possible order in which the students could have come to CTOP. If such an order does not exist, then print that this is impossible.
Please note that some students could work independently until the end of the day, without participating in a team contest.
Input
The first line contains integer n (1 ≤ n ≤ 2·105) — the number of students who came to CTOP. The next line contains n integers a1, a2, ..., an (0 ≤ ai < n), where ai is the number of students with who the i-th student shook hands.
Output
If the sought order of students exists, print in the first line "Possible" and in the second line print the permutation of the students' numbers defining the order in which the students entered the center. Number i that stands to the left of number j in this permutation means that the i-th student came earlier than the j-th student. If there are multiple answers, print any of them.
If the sought order of students doesn't exist, in a single line print "Impossible".
Examples
Input
5
2 1 3 0 1
Output
Possible
4 5 1 3 2
Input
9
0 2 3 4 1 1 0 2 2
Output
Possible
7 5 2 1 6 8 3 4 9
Input
4
0 2 1 1
Output
Impossible
Note
In the first sample from the statement the order of events could be as follows:
* student 4 comes in (a4 = 0), he has no one to greet;
* student 5 comes in (a5 = 1), he shakes hands with student 4;
* student 1 comes in (a1 = 2), he shakes hands with two students (students 4, 5);
* student 3 comes in (a3 = 3), he shakes hands with three students (students 4, 5, 1);
* students 4, 5, 3 form a team and start writing a contest;
* student 2 comes in (a2 = 1), he shakes hands with one student (number 1).
In the second sample from the statement the order of events could be as follows:
* student 7 comes in (a7 = 0), he has nobody to greet;
* student 5 comes in (a5 = 1), he shakes hands with student 7;
* student 2 comes in (a2 = 2), he shakes hands with two students (students 7, 5);
* students 7, 5, 2 form a team and start writing a contest;
* student 1 comes in(a1 = 0), he has no one to greet (everyone is busy with the contest);
* student 6 comes in (a6 = 1), he shakes hands with student 1;
* student 8 comes in (a8 = 2), he shakes hands with two students (students 1, 6);
* student 3 comes in (a3 = 3), he shakes hands with three students (students 1, 6, 8);
* student 4 comes in (a4 = 4), he shakes hands with four students (students 1, 6, 8, 3);
* students 8, 3, 4 form a team and start writing a contest;
* student 9 comes in (a9 = 2), he shakes hands with two students (students 1, 6).
In the third sample from the statement the order of events is restored unambiguously:
* student 1 comes in (a1 = 0), he has no one to greet;
* student 3 comes in (or student 4) (a3 = a4 = 1), he shakes hands with student 1;
* student 2 comes in (a2 = 2), he shakes hands with two students (students 1, 3 (or 4));
* the remaining student 4 (or student 3), must shake one student's hand (a3 = a4 = 1) but it is impossible as there are only two scenarios: either a team formed and he doesn't greet anyone, or he greets all the three present people who work individually.
Submitted Solution:
```
n = int(input())
p = [int(x) for x in input().split()]
c = [[] for _ in range(n)]
t = 0
for i,x in enumerate(p):
c[x].append(i)
res = []
while True:
while len(c[t]) == 0 and t > 0:
t -= 3
if len(c[t]) == 0:
break
res.append(c[t].pop()+1)
t += 1
if all(len(x) == 0 for x in c):
print("POSSIBLE")
print(" ".join(map(str, res)))
else: print("Impossible")
``` | instruction | 0 | 70,241 | 17 | 140,482 |
No | output | 1 | 70,241 | 17 | 140,483 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
On February, 30th n students came in the Center for Training Olympiad Programmers (CTOP) of the Berland State University. They came one by one, one after another. Each of them went in, and before sitting down at his desk, greeted with those who were present in the room by shaking hands. Each of the students who came in stayed in CTOP until the end of the day and never left.
At any time any three students could join together and start participating in a team contest, which lasted until the end of the day. The team did not distract from the contest for a minute, so when another student came in and greeted those who were present, he did not shake hands with the members of the contest writing team. Each team consisted of exactly three students, and each student could not become a member of more than one team. Different teams could start writing contest at different times.
Given how many present people shook the hands of each student, get a possible order in which the students could have come to CTOP. If such an order does not exist, then print that this is impossible.
Please note that some students could work independently until the end of the day, without participating in a team contest.
Input
The first line contains integer n (1 ≤ n ≤ 2·105) — the number of students who came to CTOP. The next line contains n integers a1, a2, ..., an (0 ≤ ai < n), where ai is the number of students with who the i-th student shook hands.
Output
If the sought order of students exists, print in the first line "Possible" and in the second line print the permutation of the students' numbers defining the order in which the students entered the center. Number i that stands to the left of number j in this permutation means that the i-th student came earlier than the j-th student. If there are multiple answers, print any of them.
If the sought order of students doesn't exist, in a single line print "Impossible".
Examples
Input
5
2 1 3 0 1
Output
Possible
4 5 1 3 2
Input
9
0 2 3 4 1 1 0 2 2
Output
Possible
7 5 2 1 6 8 3 4 9
Input
4
0 2 1 1
Output
Impossible
Note
In the first sample from the statement the order of events could be as follows:
* student 4 comes in (a4 = 0), he has no one to greet;
* student 5 comes in (a5 = 1), he shakes hands with student 4;
* student 1 comes in (a1 = 2), he shakes hands with two students (students 4, 5);
* student 3 comes in (a3 = 3), he shakes hands with three students (students 4, 5, 1);
* students 4, 5, 3 form a team and start writing a contest;
* student 2 comes in (a2 = 1), he shakes hands with one student (number 1).
In the second sample from the statement the order of events could be as follows:
* student 7 comes in (a7 = 0), he has nobody to greet;
* student 5 comes in (a5 = 1), he shakes hands with student 7;
* student 2 comes in (a2 = 2), he shakes hands with two students (students 7, 5);
* students 7, 5, 2 form a team and start writing a contest;
* student 1 comes in(a1 = 0), he has no one to greet (everyone is busy with the contest);
* student 6 comes in (a6 = 1), he shakes hands with student 1;
* student 8 comes in (a8 = 2), he shakes hands with two students (students 1, 6);
* student 3 comes in (a3 = 3), he shakes hands with three students (students 1, 6, 8);
* student 4 comes in (a4 = 4), he shakes hands with four students (students 1, 6, 8, 3);
* students 8, 3, 4 form a team and start writing a contest;
* student 9 comes in (a9 = 2), he shakes hands with two students (students 1, 6).
In the third sample from the statement the order of events is restored unambiguously:
* student 1 comes in (a1 = 0), he has no one to greet;
* student 3 comes in (or student 4) (a3 = a4 = 1), he shakes hands with student 1;
* student 2 comes in (a2 = 2), he shakes hands with two students (students 1, 3 (or 4));
* the remaining student 4 (or student 3), must shake one student's hand (a3 = a4 = 1) but it is impossible as there are only two scenarios: either a team formed and he doesn't greet anyone, or he greets all the three present people who work individually.
Submitted Solution:
```
'''input
9
0 2 3 4 1 1 0 2 2
'''
from sys import stdin, setrecursionlimit
from itertools import combinations
import collections
# heapdict source
def doc(s):
if hasattr(s, '__call__'):
s = s.__doc__
def f(g):
g.__doc__ = s
return g
return f
class heapdict(collections.MutableMapping):
__marker = object()
@staticmethod
def _parent(i):
return ((i - 1) >> 1)
@staticmethod
def _left(i):
return ((i << 1) + 1)
@staticmethod
def _right(i):
return ((i+1) << 1)
def __init__(self, *args, **kw):
self.heap = []
self.d = {}
self.update(*args, **kw)
@doc(dict.clear)
def clear(self):
self.heap.clear()
self.d.clear()
@doc(dict.__setitem__)
def __setitem__(self, key, value):
if key in self.d:
self.pop(key)
wrapper = [value, key, len(self)]
self.d[key] = wrapper
self.heap.append(wrapper)
self._decrease_key(len(self.heap)-1)
def _min_heapify(self, i):
l = self._left(i)
r = self._right(i)
n = len(self.heap)
if l < n and self.heap[l][0] < self.heap[i][0]:
low = l
else:
low = i
if r < n and self.heap[r][0] < self.heap[low][0]:
low = r
if low != i:
self._swap(i, low)
self._min_heapify(low)
def _decrease_key(self, i):
while i:
parent = self._parent(i)
if self.heap[parent][0] < self.heap[i][0]: break
self._swap(i, parent)
i = parent
def _swap(self, i, j):
self.heap[i], self.heap[j] = self.heap[j], self.heap[i]
self.heap[i][2] = i
self.heap[j][2] = j
@doc(dict.__delitem__)
def __delitem__(self, key):
wrapper = self.d[key]
while wrapper[2]:
parentpos = self._parent(wrapper[2])
parent = self.heap[parentpos]
self._swap(wrapper[2], parent[2])
self.popitem()
@doc(dict.__getitem__)
def __getitem__(self, key):
return self.d[key][0]
@doc(dict.__iter__)
def __iter__(self):
return iter(self.d)
def popitem(self):
"""D.popitem() -> (k, v), remove and return the (key, value) pair with lowest\nvalue; but raise KeyError if D is empty."""
wrapper = self.heap[0]
if len(self.heap) == 1:
self.heap.pop()
else:
self.heap[0] = self.heap.pop(-1)
self.heap[0][2] = 0
self._min_heapify(0)
del self.d[wrapper[1]]
return wrapper[1], wrapper[0]
@doc(dict.__len__)
def __len__(self):
return len(self.d)
def peekitem(self):
"""D.peekitem() -> (k, v), return the (key, value) pair with lowest value;\n but raise KeyError if D is empty."""
return (self.heap[0][1], self.heap[0][0])
del doc
__all__ = ['heapdict']
setrecursionlimit(200000)
# main starts
n = int(stdin.readline().strip())
aux = list(map(int, stdin.readline().split()))
index = collections.defaultdict(list)
count = dict()
for i in range(n):
index[aux[i]].append(i + 1)
if aux[i] in count:
count[aux[i]] += 1
else:
count[aux[i]] = 1
mheap = heapdict()
for i in aux:
mheap[i] = -i
ans = []
current = [-1]
while len(mheap) > 0:
num, value = mheap.popitem()
if current[-1] < num:
temp = current[-1]
while temp != num - 1:
# print(current)
if temp + 1 in mheap:
mheap[temp + 1] = -float('inf')
temp, value = mheap.popitem()
ans.append(index[temp].pop())
current.append(temp)
count[temp] -= 1
if count[temp] > 0:
mheap[temp] = -temp
else:
print("Impossible")
exit()
current.append(num)
ans.append(index[num].pop())
# print(current)
else:
while current[-1] >= num:
if len(current) < 4:
print('Impossiple')
exit()
else:
current.pop()
current.pop()
current.pop()
mheap[num] = -num
print("Possible")
print(*ans)
``` | instruction | 0 | 70,242 | 17 | 140,484 |
No | output | 1 | 70,242 | 17 | 140,485 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This year, as in previous years, MemSQL is inviting the top 25 competitors from the Start[c]up qualification round to compete onsite for the final round. Not everyone who is eligible to compete onsite can afford to travel to the office, though. Initially the top 25 contestants are invited to come onsite. Each eligible contestant must either accept or decline the invitation. Whenever a contestant declines, the highest ranked contestant not yet invited is invited to take the place of the one that declined. This continues until 25 contestants have accepted invitations.
After the qualifying round completes, you know K of the onsite finalists, as well as their qualifying ranks (which start at 1, there are no ties). Determine the minimum possible number of contestants that declined the invitation to compete onsite in the final round.
Input
The first line of input contains K (1 ≤ K ≤ 25), the number of onsite finalists you know. The second line of input contains r1, r2, ..., rK (1 ≤ ri ≤ 106), the qualifying ranks of the finalists you know. All these ranks are distinct.
Output
Print the minimum possible number of contestants that declined the invitation to compete onsite.
Examples
Input
25
2 3 4 5 6 7 8 9 10 11 12 14 15 16 17 18 19 20 21 22 23 24 25 26 28
Output
3
Input
5
16 23 8 15 4
Output
0
Input
3
14 15 92
Output
67
Note
In the first example, you know all 25 onsite finalists. The contestants who ranked 1-st, 13-th, and 27-th must have declined, so the answer is 3. | instruction | 0 | 70,402 | 17 | 140,804 |
Tags: greedy, implementation
Correct Solution:
```
b=int(input())
a=list(map(int,input().split()))
b=0
a.sort()
for i in range(b):
if a[i]>25:
b+=1
if a[-1]>25:
b=b+(a[-1]-25-b)
print(b)
``` | output | 1 | 70,402 | 17 | 140,805 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This year, as in previous years, MemSQL is inviting the top 25 competitors from the Start[c]up qualification round to compete onsite for the final round. Not everyone who is eligible to compete onsite can afford to travel to the office, though. Initially the top 25 contestants are invited to come onsite. Each eligible contestant must either accept or decline the invitation. Whenever a contestant declines, the highest ranked contestant not yet invited is invited to take the place of the one that declined. This continues until 25 contestants have accepted invitations.
After the qualifying round completes, you know K of the onsite finalists, as well as their qualifying ranks (which start at 1, there are no ties). Determine the minimum possible number of contestants that declined the invitation to compete onsite in the final round.
Input
The first line of input contains K (1 ≤ K ≤ 25), the number of onsite finalists you know. The second line of input contains r1, r2, ..., rK (1 ≤ ri ≤ 106), the qualifying ranks of the finalists you know. All these ranks are distinct.
Output
Print the minimum possible number of contestants that declined the invitation to compete onsite.
Examples
Input
25
2 3 4 5 6 7 8 9 10 11 12 14 15 16 17 18 19 20 21 22 23 24 25 26 28
Output
3
Input
5
16 23 8 15 4
Output
0
Input
3
14 15 92
Output
67
Note
In the first example, you know all 25 onsite finalists. The contestants who ranked 1-st, 13-th, and 27-th must have declined, so the answer is 3. | instruction | 0 | 70,403 | 17 | 140,806 |
Tags: greedy, implementation
Correct Solution:
```
def invited(lst):
return max(0, max(lst) - 25)
n = int(input())
a = [int(i) for i in input().split()]
print(invited(a))
``` | output | 1 | 70,403 | 17 | 140,807 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This year, as in previous years, MemSQL is inviting the top 25 competitors from the Start[c]up qualification round to compete onsite for the final round. Not everyone who is eligible to compete onsite can afford to travel to the office, though. Initially the top 25 contestants are invited to come onsite. Each eligible contestant must either accept or decline the invitation. Whenever a contestant declines, the highest ranked contestant not yet invited is invited to take the place of the one that declined. This continues until 25 contestants have accepted invitations.
After the qualifying round completes, you know K of the onsite finalists, as well as their qualifying ranks (which start at 1, there are no ties). Determine the minimum possible number of contestants that declined the invitation to compete onsite in the final round.
Input
The first line of input contains K (1 ≤ K ≤ 25), the number of onsite finalists you know. The second line of input contains r1, r2, ..., rK (1 ≤ ri ≤ 106), the qualifying ranks of the finalists you know. All these ranks are distinct.
Output
Print the minimum possible number of contestants that declined the invitation to compete onsite.
Examples
Input
25
2 3 4 5 6 7 8 9 10 11 12 14 15 16 17 18 19 20 21 22 23 24 25 26 28
Output
3
Input
5
16 23 8 15 4
Output
0
Input
3
14 15 92
Output
67
Note
In the first example, you know all 25 onsite finalists. The contestants who ranked 1-st, 13-th, and 27-th must have declined, so the answer is 3. | instruction | 0 | 70,404 | 17 | 140,808 |
Tags: greedy, implementation
Correct Solution:
```
n =int(input())
x = max([int(d)for d in input().split()])
if x<=25:
print(0)
else:
print(x-25)
``` | output | 1 | 70,404 | 17 | 140,809 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This year, as in previous years, MemSQL is inviting the top 25 competitors from the Start[c]up qualification round to compete onsite for the final round. Not everyone who is eligible to compete onsite can afford to travel to the office, though. Initially the top 25 contestants are invited to come onsite. Each eligible contestant must either accept or decline the invitation. Whenever a contestant declines, the highest ranked contestant not yet invited is invited to take the place of the one that declined. This continues until 25 contestants have accepted invitations.
After the qualifying round completes, you know K of the onsite finalists, as well as their qualifying ranks (which start at 1, there are no ties). Determine the minimum possible number of contestants that declined the invitation to compete onsite in the final round.
Input
The first line of input contains K (1 ≤ K ≤ 25), the number of onsite finalists you know. The second line of input contains r1, r2, ..., rK (1 ≤ ri ≤ 106), the qualifying ranks of the finalists you know. All these ranks are distinct.
Output
Print the minimum possible number of contestants that declined the invitation to compete onsite.
Examples
Input
25
2 3 4 5 6 7 8 9 10 11 12 14 15 16 17 18 19 20 21 22 23 24 25 26 28
Output
3
Input
5
16 23 8 15 4
Output
0
Input
3
14 15 92
Output
67
Note
In the first example, you know all 25 onsite finalists. The contestants who ranked 1-st, 13-th, and 27-th must have declined, so the answer is 3. | instruction | 0 | 70,405 | 17 | 140,810 |
Tags: greedy, implementation
Correct Solution:
```
k = int(input())
r = list(map(int, input().split()))
m = max(r)
if m < 25:
print(0)
else:
print(m - 25)
``` | output | 1 | 70,405 | 17 | 140,811 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This year, as in previous years, MemSQL is inviting the top 25 competitors from the Start[c]up qualification round to compete onsite for the final round. Not everyone who is eligible to compete onsite can afford to travel to the office, though. Initially the top 25 contestants are invited to come onsite. Each eligible contestant must either accept or decline the invitation. Whenever a contestant declines, the highest ranked contestant not yet invited is invited to take the place of the one that declined. This continues until 25 contestants have accepted invitations.
After the qualifying round completes, you know K of the onsite finalists, as well as their qualifying ranks (which start at 1, there are no ties). Determine the minimum possible number of contestants that declined the invitation to compete onsite in the final round.
Input
The first line of input contains K (1 ≤ K ≤ 25), the number of onsite finalists you know. The second line of input contains r1, r2, ..., rK (1 ≤ ri ≤ 106), the qualifying ranks of the finalists you know. All these ranks are distinct.
Output
Print the minimum possible number of contestants that declined the invitation to compete onsite.
Examples
Input
25
2 3 4 5 6 7 8 9 10 11 12 14 15 16 17 18 19 20 21 22 23 24 25 26 28
Output
3
Input
5
16 23 8 15 4
Output
0
Input
3
14 15 92
Output
67
Note
In the first example, you know all 25 onsite finalists. The contestants who ranked 1-st, 13-th, and 27-th must have declined, so the answer is 3. | instruction | 0 | 70,406 | 17 | 140,812 |
Tags: greedy, implementation
Correct Solution:
```
k = int(input())
arr = list(map(int,input().split()))
arr.sort()
if arr[k-1] - 25 > 0:
print(arr[k-1] - 25)
else:
print("0")
``` | output | 1 | 70,406 | 17 | 140,813 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This year, as in previous years, MemSQL is inviting the top 25 competitors from the Start[c]up qualification round to compete onsite for the final round. Not everyone who is eligible to compete onsite can afford to travel to the office, though. Initially the top 25 contestants are invited to come onsite. Each eligible contestant must either accept or decline the invitation. Whenever a contestant declines, the highest ranked contestant not yet invited is invited to take the place of the one that declined. This continues until 25 contestants have accepted invitations.
After the qualifying round completes, you know K of the onsite finalists, as well as their qualifying ranks (which start at 1, there are no ties). Determine the minimum possible number of contestants that declined the invitation to compete onsite in the final round.
Input
The first line of input contains K (1 ≤ K ≤ 25), the number of onsite finalists you know. The second line of input contains r1, r2, ..., rK (1 ≤ ri ≤ 106), the qualifying ranks of the finalists you know. All these ranks are distinct.
Output
Print the minimum possible number of contestants that declined the invitation to compete onsite.
Examples
Input
25
2 3 4 5 6 7 8 9 10 11 12 14 15 16 17 18 19 20 21 22 23 24 25 26 28
Output
3
Input
5
16 23 8 15 4
Output
0
Input
3
14 15 92
Output
67
Note
In the first example, you know all 25 onsite finalists. The contestants who ranked 1-st, 13-th, and 27-th must have declined, so the answer is 3. | instruction | 0 | 70,407 | 17 | 140,814 |
Tags: greedy, implementation
Correct Solution:
```
n = int(input())
contestants = [int(i) for i in input().split(' ')]
contestants.sort(reverse=True)
if n <= 25 and contestants[0] > 25: print(contestants[0] - 25)
# elif n == 25 and contestants[0] > 25: print(contestants[0] - 25)
else: print(0)
``` | output | 1 | 70,407 | 17 | 140,815 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This year, as in previous years, MemSQL is inviting the top 25 competitors from the Start[c]up qualification round to compete onsite for the final round. Not everyone who is eligible to compete onsite can afford to travel to the office, though. Initially the top 25 contestants are invited to come onsite. Each eligible contestant must either accept or decline the invitation. Whenever a contestant declines, the highest ranked contestant not yet invited is invited to take the place of the one that declined. This continues until 25 contestants have accepted invitations.
After the qualifying round completes, you know K of the onsite finalists, as well as their qualifying ranks (which start at 1, there are no ties). Determine the minimum possible number of contestants that declined the invitation to compete onsite in the final round.
Input
The first line of input contains K (1 ≤ K ≤ 25), the number of onsite finalists you know. The second line of input contains r1, r2, ..., rK (1 ≤ ri ≤ 106), the qualifying ranks of the finalists you know. All these ranks are distinct.
Output
Print the minimum possible number of contestants that declined the invitation to compete onsite.
Examples
Input
25
2 3 4 5 6 7 8 9 10 11 12 14 15 16 17 18 19 20 21 22 23 24 25 26 28
Output
3
Input
5
16 23 8 15 4
Output
0
Input
3
14 15 92
Output
67
Note
In the first example, you know all 25 onsite finalists. The contestants who ranked 1-st, 13-th, and 27-th must have declined, so the answer is 3. | instruction | 0 | 70,408 | 17 | 140,816 |
Tags: greedy, implementation
Correct Solution:
```
n=int(input())
print(max(0,max(list(map(int,input().split())))-25))
``` | output | 1 | 70,408 | 17 | 140,817 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This year, as in previous years, MemSQL is inviting the top 25 competitors from the Start[c]up qualification round to compete onsite for the final round. Not everyone who is eligible to compete onsite can afford to travel to the office, though. Initially the top 25 contestants are invited to come onsite. Each eligible contestant must either accept or decline the invitation. Whenever a contestant declines, the highest ranked contestant not yet invited is invited to take the place of the one that declined. This continues until 25 contestants have accepted invitations.
After the qualifying round completes, you know K of the onsite finalists, as well as their qualifying ranks (which start at 1, there are no ties). Determine the minimum possible number of contestants that declined the invitation to compete onsite in the final round.
Input
The first line of input contains K (1 ≤ K ≤ 25), the number of onsite finalists you know. The second line of input contains r1, r2, ..., rK (1 ≤ ri ≤ 106), the qualifying ranks of the finalists you know. All these ranks are distinct.
Output
Print the minimum possible number of contestants that declined the invitation to compete onsite.
Examples
Input
25
2 3 4 5 6 7 8 9 10 11 12 14 15 16 17 18 19 20 21 22 23 24 25 26 28
Output
3
Input
5
16 23 8 15 4
Output
0
Input
3
14 15 92
Output
67
Note
In the first example, you know all 25 onsite finalists. The contestants who ranked 1-st, 13-th, and 27-th must have declined, so the answer is 3. | instruction | 0 | 70,409 | 17 | 140,818 |
Tags: greedy, implementation
Correct Solution:
```
def solve(n, r):
return max(0, max(r) - 25)
def main():
n = int(input())
r = list(map(int, input().split()))
print(solve(n, r))
main()
``` | output | 1 | 70,409 | 17 | 140,819 |
Provide a correct Python 3 solution for this coding contest problem.
Ito joined the Kyudo club after entering high school. At first, I had a hard time because the arrow didn't reach the target, but in the fall of my first year of high school, I managed to improve to the point where the arrow reached the target.
One day, my senior Kato suggested, "Why don't you participate in a recent Kyudo competition?" Ito is ready to take on the challenge of the first tournament.
In the near-field competition, four lines are shot (shooting arrows) at a time, and the number of hits (the number of hits) is recorded. Repeat this multiple times to compete for the total number of hits.
For Ito-kun, who is practicing hard for the tournament, Kato-kun decided to create a program that can calculate the total middle number assuming the actual performance.
This program reads the total number of shots n and the number of hits each time, and outputs the total number of hits.
For example, if the total number of shots is 20, then 4 lines are shot 5 times at a time, so enter the number of hits 5 times.
Input
Multiple datasets are given as input.
The first line of each dataset is given n (an integer that is a multiple of 4). Then n / 4 integers are given on each line to indicate the number of hits each time.
When n is 0, it indicates the end of input. Do not output to this input.
Output
For each dataset, print the total middle number on one line.
Example
Input
20
4
3
2
1
3
8
2
0
0
Output
13
2 | instruction | 0 | 70,677 | 17 | 141,354 |
"Correct Solution:
```
sum_list = []
while True:
n = int(input())
if n == 0:
break
n //= 4
sum = 0
for _ in range(n):
sum += int(input())
sum_list.append(sum)
for sum_e in sum_list:
print(sum_e)
``` | output | 1 | 70,677 | 17 | 141,355 |
Provide a correct Python 3 solution for this coding contest problem.
Ito joined the Kyudo club after entering high school. At first, I had a hard time because the arrow didn't reach the target, but in the fall of my first year of high school, I managed to improve to the point where the arrow reached the target.
One day, my senior Kato suggested, "Why don't you participate in a recent Kyudo competition?" Ito is ready to take on the challenge of the first tournament.
In the near-field competition, four lines are shot (shooting arrows) at a time, and the number of hits (the number of hits) is recorded. Repeat this multiple times to compete for the total number of hits.
For Ito-kun, who is practicing hard for the tournament, Kato-kun decided to create a program that can calculate the total middle number assuming the actual performance.
This program reads the total number of shots n and the number of hits each time, and outputs the total number of hits.
For example, if the total number of shots is 20, then 4 lines are shot 5 times at a time, so enter the number of hits 5 times.
Input
Multiple datasets are given as input.
The first line of each dataset is given n (an integer that is a multiple of 4). Then n / 4 integers are given on each line to indicate the number of hits each time.
When n is 0, it indicates the end of input. Do not output to this input.
Output
For each dataset, print the total middle number on one line.
Example
Input
20
4
3
2
1
3
8
2
0
0
Output
13
2 | instruction | 0 | 70,678 | 17 | 141,356 |
"Correct Solution:
```
while True:
n = int(input())
if n == 0:break
print(sum([int(input()) for _ in range(int(n / 4))]))
``` | output | 1 | 70,678 | 17 | 141,357 |
Provide a correct Python 3 solution for this coding contest problem.
Ito joined the Kyudo club after entering high school. At first, I had a hard time because the arrow didn't reach the target, but in the fall of my first year of high school, I managed to improve to the point where the arrow reached the target.
One day, my senior Kato suggested, "Why don't you participate in a recent Kyudo competition?" Ito is ready to take on the challenge of the first tournament.
In the near-field competition, four lines are shot (shooting arrows) at a time, and the number of hits (the number of hits) is recorded. Repeat this multiple times to compete for the total number of hits.
For Ito-kun, who is practicing hard for the tournament, Kato-kun decided to create a program that can calculate the total middle number assuming the actual performance.
This program reads the total number of shots n and the number of hits each time, and outputs the total number of hits.
For example, if the total number of shots is 20, then 4 lines are shot 5 times at a time, so enter the number of hits 5 times.
Input
Multiple datasets are given as input.
The first line of each dataset is given n (an integer that is a multiple of 4). Then n / 4 integers are given on each line to indicate the number of hits each time.
When n is 0, it indicates the end of input. Do not output to this input.
Output
For each dataset, print the total middle number on one line.
Example
Input
20
4
3
2
1
3
8
2
0
0
Output
13
2 | instruction | 0 | 70,679 | 17 | 141,358 |
"Correct Solution:
```
while True:
a = int(input())
if a == 0:
break
count = 0
for _ in range(int(a / 4)):
b = int(input())
count += b
print(count)
``` | output | 1 | 70,679 | 17 | 141,359 |
Provide a correct Python 3 solution for this coding contest problem.
Ito joined the Kyudo club after entering high school. At first, I had a hard time because the arrow didn't reach the target, but in the fall of my first year of high school, I managed to improve to the point where the arrow reached the target.
One day, my senior Kato suggested, "Why don't you participate in a recent Kyudo competition?" Ito is ready to take on the challenge of the first tournament.
In the near-field competition, four lines are shot (shooting arrows) at a time, and the number of hits (the number of hits) is recorded. Repeat this multiple times to compete for the total number of hits.
For Ito-kun, who is practicing hard for the tournament, Kato-kun decided to create a program that can calculate the total middle number assuming the actual performance.
This program reads the total number of shots n and the number of hits each time, and outputs the total number of hits.
For example, if the total number of shots is 20, then 4 lines are shot 5 times at a time, so enter the number of hits 5 times.
Input
Multiple datasets are given as input.
The first line of each dataset is given n (an integer that is a multiple of 4). Then n / 4 integers are given on each line to indicate the number of hits each time.
When n is 0, it indicates the end of input. Do not output to this input.
Output
For each dataset, print the total middle number on one line.
Example
Input
20
4
3
2
1
3
8
2
0
0
Output
13
2 | instruction | 0 | 70,680 | 17 | 141,360 |
"Correct Solution:
```
while True:
num = int(input())
if num == 0:
break
else:
kei = 0
for _ in range(int(num / 4)):
num1 = int(input())
kei += num1
print(kei)
``` | output | 1 | 70,680 | 17 | 141,361 |
Provide a correct Python 3 solution for this coding contest problem.
Ito joined the Kyudo club after entering high school. At first, I had a hard time because the arrow didn't reach the target, but in the fall of my first year of high school, I managed to improve to the point where the arrow reached the target.
One day, my senior Kato suggested, "Why don't you participate in a recent Kyudo competition?" Ito is ready to take on the challenge of the first tournament.
In the near-field competition, four lines are shot (shooting arrows) at a time, and the number of hits (the number of hits) is recorded. Repeat this multiple times to compete for the total number of hits.
For Ito-kun, who is practicing hard for the tournament, Kato-kun decided to create a program that can calculate the total middle number assuming the actual performance.
This program reads the total number of shots n and the number of hits each time, and outputs the total number of hits.
For example, if the total number of shots is 20, then 4 lines are shot 5 times at a time, so enter the number of hits 5 times.
Input
Multiple datasets are given as input.
The first line of each dataset is given n (an integer that is a multiple of 4). Then n / 4 integers are given on each line to indicate the number of hits each time.
When n is 0, it indicates the end of input. Do not output to this input.
Output
For each dataset, print the total middle number on one line.
Example
Input
20
4
3
2
1
3
8
2
0
0
Output
13
2 | instruction | 0 | 70,681 | 17 | 141,362 |
"Correct Solution:
```
while True :
n = int(input())
if n == 0 :
break
sum = 0
for i in range(int(n/4)) :
sum += int(input())
print(sum)
``` | output | 1 | 70,681 | 17 | 141,363 |
Provide a correct Python 3 solution for this coding contest problem.
Ito joined the Kyudo club after entering high school. At first, I had a hard time because the arrow didn't reach the target, but in the fall of my first year of high school, I managed to improve to the point where the arrow reached the target.
One day, my senior Kato suggested, "Why don't you participate in a recent Kyudo competition?" Ito is ready to take on the challenge of the first tournament.
In the near-field competition, four lines are shot (shooting arrows) at a time, and the number of hits (the number of hits) is recorded. Repeat this multiple times to compete for the total number of hits.
For Ito-kun, who is practicing hard for the tournament, Kato-kun decided to create a program that can calculate the total middle number assuming the actual performance.
This program reads the total number of shots n and the number of hits each time, and outputs the total number of hits.
For example, if the total number of shots is 20, then 4 lines are shot 5 times at a time, so enter the number of hits 5 times.
Input
Multiple datasets are given as input.
The first line of each dataset is given n (an integer that is a multiple of 4). Then n / 4 integers are given on each line to indicate the number of hits each time.
When n is 0, it indicates the end of input. Do not output to this input.
Output
For each dataset, print the total middle number on one line.
Example
Input
20
4
3
2
1
3
8
2
0
0
Output
13
2 | instruction | 0 | 70,682 | 17 | 141,364 |
"Correct Solution:
```
while(True):
N = int(input())
if N==0:
break
time = N // 4
goukei = 0
for i in range(time):
ipt = int(input())
goukei += ipt
print(goukei)
``` | output | 1 | 70,682 | 17 | 141,365 |
Provide a correct Python 3 solution for this coding contest problem.
Ito joined the Kyudo club after entering high school. At first, I had a hard time because the arrow didn't reach the target, but in the fall of my first year of high school, I managed to improve to the point where the arrow reached the target.
One day, my senior Kato suggested, "Why don't you participate in a recent Kyudo competition?" Ito is ready to take on the challenge of the first tournament.
In the near-field competition, four lines are shot (shooting arrows) at a time, and the number of hits (the number of hits) is recorded. Repeat this multiple times to compete for the total number of hits.
For Ito-kun, who is practicing hard for the tournament, Kato-kun decided to create a program that can calculate the total middle number assuming the actual performance.
This program reads the total number of shots n and the number of hits each time, and outputs the total number of hits.
For example, if the total number of shots is 20, then 4 lines are shot 5 times at a time, so enter the number of hits 5 times.
Input
Multiple datasets are given as input.
The first line of each dataset is given n (an integer that is a multiple of 4). Then n / 4 integers are given on each line to indicate the number of hits each time.
When n is 0, it indicates the end of input. Do not output to this input.
Output
For each dataset, print the total middle number on one line.
Example
Input
20
4
3
2
1
3
8
2
0
0
Output
13
2 | instruction | 0 | 70,683 | 17 | 141,366 |
"Correct Solution:
```
while True:
n=int(input())
if n==0:
exit()
ans=0
for i in range(n//4):
x=int(input())
ans+=x
print(ans)
``` | output | 1 | 70,683 | 17 | 141,367 |
Provide a correct Python 3 solution for this coding contest problem.
Ito joined the Kyudo club after entering high school. At first, I had a hard time because the arrow didn't reach the target, but in the fall of my first year of high school, I managed to improve to the point where the arrow reached the target.
One day, my senior Kato suggested, "Why don't you participate in a recent Kyudo competition?" Ito is ready to take on the challenge of the first tournament.
In the near-field competition, four lines are shot (shooting arrows) at a time, and the number of hits (the number of hits) is recorded. Repeat this multiple times to compete for the total number of hits.
For Ito-kun, who is practicing hard for the tournament, Kato-kun decided to create a program that can calculate the total middle number assuming the actual performance.
This program reads the total number of shots n and the number of hits each time, and outputs the total number of hits.
For example, if the total number of shots is 20, then 4 lines are shot 5 times at a time, so enter the number of hits 5 times.
Input
Multiple datasets are given as input.
The first line of each dataset is given n (an integer that is a multiple of 4). Then n / 4 integers are given on each line to indicate the number of hits each time.
When n is 0, it indicates the end of input. Do not output to this input.
Output
For each dataset, print the total middle number on one line.
Example
Input
20
4
3
2
1
3
8
2
0
0
Output
13
2 | instruction | 0 | 70,684 | 17 | 141,368 |
"Correct Solution:
```
N=int(input())
while N!=0:
s=[]
for i in range(int(N/4)):
s.append(int(input()))
print(sum(s))
N=int(input())
``` | output | 1 | 70,684 | 17 | 141,369 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Smart Beaver decided to be not only smart, but also a healthy beaver! And so he began to attend physical education classes at school X. In this school, physical education has a very creative teacher. One of his favorite warm-up exercises is throwing balls. Students line up. Each one gets a single ball in the beginning. The balls are numbered from 1 to n (by the demand of the inventory commission).
<image> Figure 1. The initial position for n = 5.
After receiving the balls the students perform the warm-up exercise. The exercise takes place in a few throws. For each throw the teacher chooses any two arbitrary different students who will participate in it. The selected students throw their balls to each other. Thus, after each throw the students remain in their positions, and the two balls are swapped.
<image> Figure 2. The example of a throw.
In this case there was a throw between the students, who were holding the 2-nd and the 4-th balls. Since the warm-up has many exercises, each of them can only continue for little time. Therefore, for each student we know the maximum number of throws he can participate in. For this lessons maximum number of throws will be 1 or 2.
Note that after all phases of the considered exercise any ball can end up with any student. Smart Beaver decided to formalize it and introduced the concept of the "ball order". The ball order is a sequence of n numbers that correspond to the order of balls in the line. The first number will match the number of the ball of the first from the left student in the line, the second number will match the ball of the second student, and so on. For example, in figure 2 the order of the balls was (1, 2, 3, 4, 5), and after the throw it was (1, 4, 3, 2, 5). Smart beaver knows the number of students and for each student he knows the maximum number of throws in which he can participate. And now he is wondering: what is the number of distinct ways of ball orders by the end of the exercise.
Input
The first line contains a single number n — the number of students in the line and the number of balls. The next line contains exactly n space-separated integers. Each number corresponds to a student in the line (the i-th number corresponds to the i-th from the left student in the line) and shows the number of throws he can participate in.
The input limits for scoring 30 points are (subproblem D1):
* 1 ≤ n ≤ 10.
The input limits for scoring 70 points are (subproblems D1+D2):
* 1 ≤ n ≤ 500.
The input limits for scoring 100 points are (subproblems D1+D2+D3):
* 1 ≤ n ≤ 1000000.
Output
The output should contain a single integer — the number of variants of ball orders after the warm up exercise is complete. As the number can be rather large, print it modulo 1000000007 (109 + 7).
Examples
Input
5
1 2 2 1 2
Output
120
Input
8
1 2 2 1 2 1 1 2
Output
16800 | instruction | 0 | 71,065 | 17 | 142,130 |
Tags: dp, math
Correct Solution:
```
m = 1000000007
n = int(input())
a = map(int, input().split())
t1, t2 = 0, 0
for i in a:
if i == 1:
t1 += 1
else:
t2 += 1
a = [1, 2]
for i in range(3, t1+1):
a = a[::-1]
a[1] = (a[0]+(i-1)*a[1])%m
if not t1 or t1 == 1:
a[1] = 1
for i in range(t1+1, n+1):
a[1] = a[1]*i%m
print(a[1])
``` | output | 1 | 71,065 | 17 | 142,131 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Smart Beaver decided to be not only smart, but also a healthy beaver! And so he began to attend physical education classes at school X. In this school, physical education has a very creative teacher. One of his favorite warm-up exercises is throwing balls. Students line up. Each one gets a single ball in the beginning. The balls are numbered from 1 to n (by the demand of the inventory commission).
<image> Figure 1. The initial position for n = 5.
After receiving the balls the students perform the warm-up exercise. The exercise takes place in a few throws. For each throw the teacher chooses any two arbitrary different students who will participate in it. The selected students throw their balls to each other. Thus, after each throw the students remain in their positions, and the two balls are swapped.
<image> Figure 2. The example of a throw.
In this case there was a throw between the students, who were holding the 2-nd and the 4-th balls. Since the warm-up has many exercises, each of them can only continue for little time. Therefore, for each student we know the maximum number of throws he can participate in. For this lessons maximum number of throws will be 1 or 2.
Note that after all phases of the considered exercise any ball can end up with any student. Smart Beaver decided to formalize it and introduced the concept of the "ball order". The ball order is a sequence of n numbers that correspond to the order of balls in the line. The first number will match the number of the ball of the first from the left student in the line, the second number will match the ball of the second student, and so on. For example, in figure 2 the order of the balls was (1, 2, 3, 4, 5), and after the throw it was (1, 4, 3, 2, 5). Smart beaver knows the number of students and for each student he knows the maximum number of throws in which he can participate. And now he is wondering: what is the number of distinct ways of ball orders by the end of the exercise.
Input
The first line contains a single number n — the number of students in the line and the number of balls. The next line contains exactly n space-separated integers. Each number corresponds to a student in the line (the i-th number corresponds to the i-th from the left student in the line) and shows the number of throws he can participate in.
The input limits for scoring 30 points are (subproblem D1):
* 1 ≤ n ≤ 10.
The input limits for scoring 70 points are (subproblems D1+D2):
* 1 ≤ n ≤ 500.
The input limits for scoring 100 points are (subproblems D1+D2+D3):
* 1 ≤ n ≤ 1000000.
Output
The output should contain a single integer — the number of variants of ball orders after the warm up exercise is complete. As the number can be rather large, print it modulo 1000000007 (109 + 7).
Examples
Input
5
1 2 2 1 2
Output
120
Input
8
1 2 2 1 2 1 1 2
Output
16800
Submitted Solution:
```
m = 1000000007
n = int(input())
a = map(int, input().split())
t1, t2 = 0, 0
for i in a:
if i == 1:
t1 += 1
else:
t2 += 1
a = [1, 2]
for i in range(3, t1+1):
a = a[::-1]
a[1] = (a[0]+(i-1)*a[1])%m
for i in range(t1+1, n+1):
a[1] = a[1]*i%m
print(a[1])
``` | instruction | 0 | 71,066 | 17 | 142,132 |
No | output | 1 | 71,066 | 17 | 142,133 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a programing contest named SnakeUp, 2n people want to compete for it. In order to attend this contest, people need to form teams of exactly two people. You are given the strength of each possible combination of two people. All the values of the strengths are distinct.
Every contestant hopes that he can find a teammate so that their team’s strength is as high as possible. That is, a contestant will form a team with highest strength possible by choosing a teammate from ones who are willing to be a teammate with him/her. More formally, two people A and B may form a team if each of them is the best possible teammate (among the contestants that remain unpaired) for the other one.
Can you determine who will be each person’s teammate?
Input
There are 2n lines in the input.
The first line contains an integer n (1 ≤ n ≤ 400) — the number of teams to be formed.
The i-th line (i > 1) contains i - 1 numbers ai1, ai2, ... , ai(i - 1). Here aij (1 ≤ aij ≤ 106, all aij are distinct) denotes the strength of a team consisting of person i and person j (people are numbered starting from 1.)
Output
Output a line containing 2n numbers. The i-th number should represent the number of teammate of i-th person.
Examples
Input
2
6
1 2
3 4 5
Output
2 1 4 3
Input
3
487060
3831 161856
845957 794650 976977
83847 50566 691206 498447
698377 156232 59015 382455 626960
Output
6 5 4 3 2 1
Note
In the first sample, contestant 1 and 2 will be teammates and so do contestant 3 and 4, so the teammate of contestant 1, 2, 3, 4 will be 2, 1, 4, 3 respectively. | instruction | 0 | 71,185 | 17 | 142,370 |
Tags: brute force, implementation, sortings
Correct Solution:
```
import sys
N = int(sys.stdin.readline())
members = list()
list_sum = list()
for i in range(2*N-1):
members.append(list(map(int, sys.stdin.readline().split())))
for j in range(len(members[i])):
list_sum.append([members[i][j], (i+2,j+1)])
list_sum.sort(key=lambda x: x[0], reverse=True)
members_set = set()
teammates = [0] * 2*N
for one_list in list_sum:
if N == 0:
break
elif one_list[1][0] not in members_set and one_list[1][1] not in members_set:
members_set.add(one_list[1][0])
members_set.add(one_list[1][1])
teammates[one_list[1][0]-1] = one_list[1][1]
teammates[one_list[1][1]-1] = one_list[1][0]
N -= 1
continue
print(' '.join(repr(e) for e in teammates))
``` | output | 1 | 71,185 | 17 | 142,371 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a programing contest named SnakeUp, 2n people want to compete for it. In order to attend this contest, people need to form teams of exactly two people. You are given the strength of each possible combination of two people. All the values of the strengths are distinct.
Every contestant hopes that he can find a teammate so that their team’s strength is as high as possible. That is, a contestant will form a team with highest strength possible by choosing a teammate from ones who are willing to be a teammate with him/her. More formally, two people A and B may form a team if each of them is the best possible teammate (among the contestants that remain unpaired) for the other one.
Can you determine who will be each person’s teammate?
Input
There are 2n lines in the input.
The first line contains an integer n (1 ≤ n ≤ 400) — the number of teams to be formed.
The i-th line (i > 1) contains i - 1 numbers ai1, ai2, ... , ai(i - 1). Here aij (1 ≤ aij ≤ 106, all aij are distinct) denotes the strength of a team consisting of person i and person j (people are numbered starting from 1.)
Output
Output a line containing 2n numbers. The i-th number should represent the number of teammate of i-th person.
Examples
Input
2
6
1 2
3 4 5
Output
2 1 4 3
Input
3
487060
3831 161856
845957 794650 976977
83847 50566 691206 498447
698377 156232 59015 382455 626960
Output
6 5 4 3 2 1
Note
In the first sample, contestant 1 and 2 will be teammates and so do contestant 3 and 4, so the teammate of contestant 1, 2, 3, 4 will be 2, 1, 4, 3 respectively. | instruction | 0 | 71,186 | 17 | 142,372 |
Tags: brute force, implementation, sortings
Correct Solution:
```
n=int(input())
out=[-1]*n*2
L=[]
for i in range(1,n*2) :
l=list(map(int,input().split()))
for j in range(len(l)) :
t=[l[j],[i+1,j+1]]
L.append(t)
L=sorted(L,key=lambda x :-x[0])
for i in range(len(L)) :
if out[L[i][1][0]-1]==out[L[i][1][1]-1]==-1 :
out[L[i][1][0]-1]=L[i][1][1]
out[L[i][1][1]-1]=L[i][1][0]
print(*out)
``` | output | 1 | 71,186 | 17 | 142,373 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a programing contest named SnakeUp, 2n people want to compete for it. In order to attend this contest, people need to form teams of exactly two people. You are given the strength of each possible combination of two people. All the values of the strengths are distinct.
Every contestant hopes that he can find a teammate so that their team’s strength is as high as possible. That is, a contestant will form a team with highest strength possible by choosing a teammate from ones who are willing to be a teammate with him/her. More formally, two people A and B may form a team if each of them is the best possible teammate (among the contestants that remain unpaired) for the other one.
Can you determine who will be each person’s teammate?
Input
There are 2n lines in the input.
The first line contains an integer n (1 ≤ n ≤ 400) — the number of teams to be formed.
The i-th line (i > 1) contains i - 1 numbers ai1, ai2, ... , ai(i - 1). Here aij (1 ≤ aij ≤ 106, all aij are distinct) denotes the strength of a team consisting of person i and person j (people are numbered starting from 1.)
Output
Output a line containing 2n numbers. The i-th number should represent the number of teammate of i-th person.
Examples
Input
2
6
1 2
3 4 5
Output
2 1 4 3
Input
3
487060
3831 161856
845957 794650 976977
83847 50566 691206 498447
698377 156232 59015 382455 626960
Output
6 5 4 3 2 1
Note
In the first sample, contestant 1 and 2 will be teammates and so do contestant 3 and 4, so the teammate of contestant 1, 2, 3, 4 will be 2, 1, 4, 3 respectively. | instruction | 0 | 71,187 | 17 | 142,374 |
Tags: brute force, implementation, sortings
Correct Solution:
```
from sys import stdin
live = True
if not live: stdin = open('data.in', 'r')
numbers = []
n = int(stdin.readline().strip())
for i in range(2, (2*n + 1)):
line = list(map(int, stdin.readline().strip().split()))
it = 1
for j in line:
numbers.append((j, i, it))
it += 1
teams = 0
pairs = [0] * (2 * n + 1)
numbers = sorted(numbers, key = lambda tup: tup[0], reverse = True)
for m, i, j in numbers:
if teams == n: break
if not pairs[i] and not pairs[j]:
pairs[i] = j
pairs[j] = i
teams += 1
print(' '.join(list(map(str, pairs[1:]))))
if not live: stdin.close()
``` | output | 1 | 71,187 | 17 | 142,375 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a programing contest named SnakeUp, 2n people want to compete for it. In order to attend this contest, people need to form teams of exactly two people. You are given the strength of each possible combination of two people. All the values of the strengths are distinct.
Every contestant hopes that he can find a teammate so that their team’s strength is as high as possible. That is, a contestant will form a team with highest strength possible by choosing a teammate from ones who are willing to be a teammate with him/her. More formally, two people A and B may form a team if each of them is the best possible teammate (among the contestants that remain unpaired) for the other one.
Can you determine who will be each person’s teammate?
Input
There are 2n lines in the input.
The first line contains an integer n (1 ≤ n ≤ 400) — the number of teams to be formed.
The i-th line (i > 1) contains i - 1 numbers ai1, ai2, ... , ai(i - 1). Here aij (1 ≤ aij ≤ 106, all aij are distinct) denotes the strength of a team consisting of person i and person j (people are numbered starting from 1.)
Output
Output a line containing 2n numbers. The i-th number should represent the number of teammate of i-th person.
Examples
Input
2
6
1 2
3 4 5
Output
2 1 4 3
Input
3
487060
3831 161856
845957 794650 976977
83847 50566 691206 498447
698377 156232 59015 382455 626960
Output
6 5 4 3 2 1
Note
In the first sample, contestant 1 and 2 will be teammates and so do contestant 3 and 4, so the teammate of contestant 1, 2, 3, 4 will be 2, 1, 4, 3 respectively. | instruction | 0 | 71,188 | 17 | 142,376 |
Tags: brute force, implementation, sortings
Correct Solution:
```
def mergeSort(arr, l, r, merge_arr):
if(l < r):
mid = int(l + r) // 2
mergeSort(arr, l, mid, merge_arr)
mergeSort(arr, mid + 1, r, merge_arr)
merge(arr, l, mid, r, merge_arr)
def merge(source, left, mid, right, merge_arr):
l = left
r = mid + 1
for i in range(left, right + 1, 1):
if(source[l][0] <= source[r][0]):
merge_arr[i] = source[l]
l = l + 1
if(l == mid + 1):
i = i + 1
for j in range(r , right + 1 , 1):
merge_arr[i] = source[j]
i = i + 1
break
else:
merge_arr[i] = source[r]
r = r + 1
if(r == right + 1):
i = i + 1
for j in range(l, mid + 1, 1):
merge_arr[i] = source[j]
i = i + 1
break
for i in range(left ,right + 1, 1):
source[i] = merge_arr[i]
a = []
n = int(input())
for i in range(2*n - 1):
acopy = input().split()
for j in range(i + 1):
a.append([int(acopy[j]), i + 1, j])
merge_arr = [[0, 0, 0] for i in range(len(a))]
answer = [0 for i in range(2*n)]
players = [False for i in range(2*n)]
"""mergeSort(a, 0, len(a) - 1, merge_arr)"""
a.sort()
for i in range(len(a) - 1, -1, -1):
if(players[a[i][1]] == False and players[a[i][2]] == False):
answer[a[i][1]] = a[i][2] + 1
answer[a[i][2]] = a[i][1] + 1
players[a[i][1]] = True
players[a[i][2]] = True
for i in range(len(answer)):
print(answer[i], end = ' ')
``` | output | 1 | 71,188 | 17 | 142,377 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a programing contest named SnakeUp, 2n people want to compete for it. In order to attend this contest, people need to form teams of exactly two people. You are given the strength of each possible combination of two people. All the values of the strengths are distinct.
Every contestant hopes that he can find a teammate so that their team’s strength is as high as possible. That is, a contestant will form a team with highest strength possible by choosing a teammate from ones who are willing to be a teammate with him/her. More formally, two people A and B may form a team if each of them is the best possible teammate (among the contestants that remain unpaired) for the other one.
Can you determine who will be each person’s teammate?
Input
There are 2n lines in the input.
The first line contains an integer n (1 ≤ n ≤ 400) — the number of teams to be formed.
The i-th line (i > 1) contains i - 1 numbers ai1, ai2, ... , ai(i - 1). Here aij (1 ≤ aij ≤ 106, all aij are distinct) denotes the strength of a team consisting of person i and person j (people are numbered starting from 1.)
Output
Output a line containing 2n numbers. The i-th number should represent the number of teammate of i-th person.
Examples
Input
2
6
1 2
3 4 5
Output
2 1 4 3
Input
3
487060
3831 161856
845957 794650 976977
83847 50566 691206 498447
698377 156232 59015 382455 626960
Output
6 5 4 3 2 1
Note
In the first sample, contestant 1 and 2 will be teammates and so do contestant 3 and 4, so the teammate of contestant 1, 2, 3, 4 will be 2, 1, 4, 3 respectively. | instruction | 0 | 71,189 | 17 | 142,378 |
Tags: brute force, implementation, sortings
Correct Solution:
```
n = int(input())*2
v = []
for i in range(1,n):
a = [int(str) for str in input().split(' ')]
for j in range(0,i):
v.append([a[j],i,j])
v.sort(reverse=True)
r = [-1] * n
for i in range(len(v)):
if r[v[i][1]] == -1 and r[v[i][2]] == -1:
r[v[i][1]] = v[i][2]
r[v[i][2]] = v[i][1]
for i in range(n):
print(str(r[i] + 1) + ' ', end="")
``` | output | 1 | 71,189 | 17 | 142,379 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a programing contest named SnakeUp, 2n people want to compete for it. In order to attend this contest, people need to form teams of exactly two people. You are given the strength of each possible combination of two people. All the values of the strengths are distinct.
Every contestant hopes that he can find a teammate so that their team’s strength is as high as possible. That is, a contestant will form a team with highest strength possible by choosing a teammate from ones who are willing to be a teammate with him/her. More formally, two people A and B may form a team if each of them is the best possible teammate (among the contestants that remain unpaired) for the other one.
Can you determine who will be each person’s teammate?
Input
There are 2n lines in the input.
The first line contains an integer n (1 ≤ n ≤ 400) — the number of teams to be formed.
The i-th line (i > 1) contains i - 1 numbers ai1, ai2, ... , ai(i - 1). Here aij (1 ≤ aij ≤ 106, all aij are distinct) denotes the strength of a team consisting of person i and person j (people are numbered starting from 1.)
Output
Output a line containing 2n numbers. The i-th number should represent the number of teammate of i-th person.
Examples
Input
2
6
1 2
3 4 5
Output
2 1 4 3
Input
3
487060
3831 161856
845957 794650 976977
83847 50566 691206 498447
698377 156232 59015 382455 626960
Output
6 5 4 3 2 1
Note
In the first sample, contestant 1 and 2 will be teammates and so do contestant 3 and 4, so the teammate of contestant 1, 2, 3, 4 will be 2, 1, 4, 3 respectively. | instruction | 0 | 71,190 | 17 | 142,380 |
Tags: brute force, implementation, sortings
Correct Solution:
```
n = int(input())
m = list()
ans = [-1] * 2 * n
for i in range(1, 2 * n):
m += map(lambda t: (i, int(t[0]), int(t[1])), enumerate(input().split()))
m = sorted(m, key=lambda t: t[2], reverse=True)
for (i, j, _) in m:
if ans[i] == -1 and ans[j] == -1:
ans[i] = j + 1
ans[j] = i + 1
print(' '.join(map(str, ans)))
``` | output | 1 | 71,190 | 17 | 142,381 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a programing contest named SnakeUp, 2n people want to compete for it. In order to attend this contest, people need to form teams of exactly two people. You are given the strength of each possible combination of two people. All the values of the strengths are distinct.
Every contestant hopes that he can find a teammate so that their team’s strength is as high as possible. That is, a contestant will form a team with highest strength possible by choosing a teammate from ones who are willing to be a teammate with him/her. More formally, two people A and B may form a team if each of them is the best possible teammate (among the contestants that remain unpaired) for the other one.
Can you determine who will be each person’s teammate?
Input
There are 2n lines in the input.
The first line contains an integer n (1 ≤ n ≤ 400) — the number of teams to be formed.
The i-th line (i > 1) contains i - 1 numbers ai1, ai2, ... , ai(i - 1). Here aij (1 ≤ aij ≤ 106, all aij are distinct) denotes the strength of a team consisting of person i and person j (people are numbered starting from 1.)
Output
Output a line containing 2n numbers. The i-th number should represent the number of teammate of i-th person.
Examples
Input
2
6
1 2
3 4 5
Output
2 1 4 3
Input
3
487060
3831 161856
845957 794650 976977
83847 50566 691206 498447
698377 156232 59015 382455 626960
Output
6 5 4 3 2 1
Note
In the first sample, contestant 1 and 2 will be teammates and so do contestant 3 and 4, so the teammate of contestant 1, 2, 3, 4 will be 2, 1, 4, 3 respectively. | instruction | 0 | 71,191 | 17 | 142,382 |
Tags: brute force, implementation, sortings
Correct Solution:
```
def main():
mode="filee"
if mode=="file":f=open("test.txt","r")
if mode=="file":n=int(f.readline())
else:n=int(input())
w=[]
for i in range(2,2*n+1):
if mode=="file":g=[int(x) for x in f.readline().split()]
else:g=[int(x) for x in input().split()]
for j in range(1,i):
w.append([g[j-1],[i,j]])
w.sort()
free=2*n
fr=[-1]*(free+1)
w.reverse()
for e,k in w:
if fr[k[0]]==-1 and fr[k[1]]==-1:
fr[k[0]]=k[1]
fr[k[1]]=k[0]
free-=1
if free==0:
break
for i in fr[1:]:
print(i,end=' ')
if mode=="file":f.close()
if __name__=="__main__":
main()
``` | output | 1 | 71,191 | 17 | 142,383 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a programing contest named SnakeUp, 2n people want to compete for it. In order to attend this contest, people need to form teams of exactly two people. You are given the strength of each possible combination of two people. All the values of the strengths are distinct.
Every contestant hopes that he can find a teammate so that their team’s strength is as high as possible. That is, a contestant will form a team with highest strength possible by choosing a teammate from ones who are willing to be a teammate with him/her. More formally, two people A and B may form a team if each of them is the best possible teammate (among the contestants that remain unpaired) for the other one.
Can you determine who will be each person’s teammate?
Input
There are 2n lines in the input.
The first line contains an integer n (1 ≤ n ≤ 400) — the number of teams to be formed.
The i-th line (i > 1) contains i - 1 numbers ai1, ai2, ... , ai(i - 1). Here aij (1 ≤ aij ≤ 106, all aij are distinct) denotes the strength of a team consisting of person i and person j (people are numbered starting from 1.)
Output
Output a line containing 2n numbers. The i-th number should represent the number of teammate of i-th person.
Examples
Input
2
6
1 2
3 4 5
Output
2 1 4 3
Input
3
487060
3831 161856
845957 794650 976977
83847 50566 691206 498447
698377 156232 59015 382455 626960
Output
6 5 4 3 2 1
Note
In the first sample, contestant 1 and 2 will be teammates and so do contestant 3 and 4, so the teammate of contestant 1, 2, 3, 4 will be 2, 1, 4, 3 respectively. | instruction | 0 | 71,192 | 17 | 142,384 |
Tags: brute force, implementation, sortings
Correct Solution:
```
n = int(input())
combs = []
for i in range(2*n - 1):
arr = [int(value) for value in input().split()]
for j,value in enumerate(arr):
combs.append(tuple([value] + sorted([i+2,j+1])))
combs.sort(reverse = True)
ans = [0] * (2 * n + 1)
for x,y,z in combs:
if ans[y] == 0 and ans[z] == 0:
ans[y] = z
ans[z] = y
for value in ans[1:]:
print(value,end=' ')
print()
``` | output | 1 | 71,192 | 17 | 142,385 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a programing contest named SnakeUp, 2n people want to compete for it. In order to attend this contest, people need to form teams of exactly two people. You are given the strength of each possible combination of two people. All the values of the strengths are distinct.
Every contestant hopes that he can find a teammate so that their team’s strength is as high as possible. That is, a contestant will form a team with highest strength possible by choosing a teammate from ones who are willing to be a teammate with him/her. More formally, two people A and B may form a team if each of them is the best possible teammate (among the contestants that remain unpaired) for the other one.
Can you determine who will be each person’s teammate?
Input
There are 2n lines in the input.
The first line contains an integer n (1 ≤ n ≤ 400) — the number of teams to be formed.
The i-th line (i > 1) contains i - 1 numbers ai1, ai2, ... , ai(i - 1). Here aij (1 ≤ aij ≤ 106, all aij are distinct) denotes the strength of a team consisting of person i and person j (people are numbered starting from 1.)
Output
Output a line containing 2n numbers. The i-th number should represent the number of teammate of i-th person.
Examples
Input
2
6
1 2
3 4 5
Output
2 1 4 3
Input
3
487060
3831 161856
845957 794650 976977
83847 50566 691206 498447
698377 156232 59015 382455 626960
Output
6 5 4 3 2 1
Note
In the first sample, contestant 1 and 2 will be teammates and so do contestant 3 and 4, so the teammate of contestant 1, 2, 3, 4 will be 2, 1, 4, 3 respectively.
Submitted Solution:
```
n = int(input())
tuples = []
for i in range(2 * n - 1):
for j, score in enumerate(map(int, input().split())):
tuples.append((-score, i + 1, j))
tuples.sort()
result = 2 * n * [ None ]
for score, i, j in tuples:
if result[i] == None and result[j] == None:
result[i] = j + 1
result[j] = i + 1
print(' '.join(map(str, result)))
``` | instruction | 0 | 71,193 | 17 | 142,386 |
Yes | output | 1 | 71,193 | 17 | 142,387 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a programing contest named SnakeUp, 2n people want to compete for it. In order to attend this contest, people need to form teams of exactly two people. You are given the strength of each possible combination of two people. All the values of the strengths are distinct.
Every contestant hopes that he can find a teammate so that their team’s strength is as high as possible. That is, a contestant will form a team with highest strength possible by choosing a teammate from ones who are willing to be a teammate with him/her. More formally, two people A and B may form a team if each of them is the best possible teammate (among the contestants that remain unpaired) for the other one.
Can you determine who will be each person’s teammate?
Input
There are 2n lines in the input.
The first line contains an integer n (1 ≤ n ≤ 400) — the number of teams to be formed.
The i-th line (i > 1) contains i - 1 numbers ai1, ai2, ... , ai(i - 1). Here aij (1 ≤ aij ≤ 106, all aij are distinct) denotes the strength of a team consisting of person i and person j (people are numbered starting from 1.)
Output
Output a line containing 2n numbers. The i-th number should represent the number of teammate of i-th person.
Examples
Input
2
6
1 2
3 4 5
Output
2 1 4 3
Input
3
487060
3831 161856
845957 794650 976977
83847 50566 691206 498447
698377 156232 59015 382455 626960
Output
6 5 4 3 2 1
Note
In the first sample, contestant 1 and 2 will be teammates and so do contestant 3 and 4, so the teammate of contestant 1, 2, 3, 4 will be 2, 1, 4, 3 respectively.
Submitted Solution:
```
n = int(input())
strength = []
for i in range(1, n*2):
ss = list(map(int, input().split()))
for j, s in enumerate(ss):
strength.append((s, i, j))
strength.sort(reverse = True)
team_mates = [0] * (2*n)
counter = 0
for s, i, j in strength:
if team_mates[i] or team_mates[j]:
continue
team_mates[i] = j + 1
team_mates[j] = i + 1
counter += 1
if counter == n:
break
print(*team_mates)
``` | instruction | 0 | 71,194 | 17 | 142,388 |
Yes | output | 1 | 71,194 | 17 | 142,389 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a programing contest named SnakeUp, 2n people want to compete for it. In order to attend this contest, people need to form teams of exactly two people. You are given the strength of each possible combination of two people. All the values of the strengths are distinct.
Every contestant hopes that he can find a teammate so that their team’s strength is as high as possible. That is, a contestant will form a team with highest strength possible by choosing a teammate from ones who are willing to be a teammate with him/her. More formally, two people A and B may form a team if each of them is the best possible teammate (among the contestants that remain unpaired) for the other one.
Can you determine who will be each person’s teammate?
Input
There are 2n lines in the input.
The first line contains an integer n (1 ≤ n ≤ 400) — the number of teams to be formed.
The i-th line (i > 1) contains i - 1 numbers ai1, ai2, ... , ai(i - 1). Here aij (1 ≤ aij ≤ 106, all aij are distinct) denotes the strength of a team consisting of person i and person j (people are numbered starting from 1.)
Output
Output a line containing 2n numbers. The i-th number should represent the number of teammate of i-th person.
Examples
Input
2
6
1 2
3 4 5
Output
2 1 4 3
Input
3
487060
3831 161856
845957 794650 976977
83847 50566 691206 498447
698377 156232 59015 382455 626960
Output
6 5 4 3 2 1
Note
In the first sample, contestant 1 and 2 will be teammates and so do contestant 3 and 4, so the teammate of contestant 1, 2, 3, 4 will be 2, 1, 4, 3 respectively.
Submitted Solution:
```
n = int(input())
a = []; b = [0]*(2*n+1); c = [0]*(2*n+1);
z = dict()
for i in range(2*n-1):
k = list(map(int, input().split()));
for j in range(len(k)):
z[k[j]] = (i+2, j+1)
a += k
a.sort(reverse = True)
for d in range(len(a)):
i, j = z[a[d]]
if not c[i] and not c[j]:
b[i] = j
b[j] = i
c[i] = c[j] = True
for i in range(1, 2*n+1):
print(b[i], end=' ')
``` | instruction | 0 | 71,195 | 17 | 142,390 |
Yes | output | 1 | 71,195 | 17 | 142,391 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a programing contest named SnakeUp, 2n people want to compete for it. In order to attend this contest, people need to form teams of exactly two people. You are given the strength of each possible combination of two people. All the values of the strengths are distinct.
Every contestant hopes that he can find a teammate so that their team’s strength is as high as possible. That is, a contestant will form a team with highest strength possible by choosing a teammate from ones who are willing to be a teammate with him/her. More formally, two people A and B may form a team if each of them is the best possible teammate (among the contestants that remain unpaired) for the other one.
Can you determine who will be each person’s teammate?
Input
There are 2n lines in the input.
The first line contains an integer n (1 ≤ n ≤ 400) — the number of teams to be formed.
The i-th line (i > 1) contains i - 1 numbers ai1, ai2, ... , ai(i - 1). Here aij (1 ≤ aij ≤ 106, all aij are distinct) denotes the strength of a team consisting of person i and person j (people are numbered starting from 1.)
Output
Output a line containing 2n numbers. The i-th number should represent the number of teammate of i-th person.
Examples
Input
2
6
1 2
3 4 5
Output
2 1 4 3
Input
3
487060
3831 161856
845957 794650 976977
83847 50566 691206 498447
698377 156232 59015 382455 626960
Output
6 5 4 3 2 1
Note
In the first sample, contestant 1 and 2 will be teammates and so do contestant 3 and 4, so the teammate of contestant 1, 2, 3, 4 will be 2, 1, 4, 3 respectively.
Submitted Solution:
```
n = int(input())
l = []
for i in range(n * 2 - 1):
l.append([int(x) for x in input().split()])
tm = [0] * (n * 2)
for i in range(n):
ms = [max(r) for r in l]
m = max(ms)
i = ms.index(m)
j = l[i].index(m)
l[i] = l[j - 1 if j else i] = [0]
for k in range(n * 2 - 1):
if i + 1 < len(l[k]):
l[k][i + 1] = 0
if j < len(l[k]):
l[k][j] = 0
i += 1
tm[i] = j + 1
tm[j] = i + 1
print(' '.join(str(x) for x in tm))
``` | instruction | 0 | 71,196 | 17 | 142,392 |
Yes | output | 1 | 71,196 | 17 | 142,393 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a programing contest named SnakeUp, 2n people want to compete for it. In order to attend this contest, people need to form teams of exactly two people. You are given the strength of each possible combination of two people. All the values of the strengths are distinct.
Every contestant hopes that he can find a teammate so that their team’s strength is as high as possible. That is, a contestant will form a team with highest strength possible by choosing a teammate from ones who are willing to be a teammate with him/her. More formally, two people A and B may form a team if each of them is the best possible teammate (among the contestants that remain unpaired) for the other one.
Can you determine who will be each person’s teammate?
Input
There are 2n lines in the input.
The first line contains an integer n (1 ≤ n ≤ 400) — the number of teams to be formed.
The i-th line (i > 1) contains i - 1 numbers ai1, ai2, ... , ai(i - 1). Here aij (1 ≤ aij ≤ 106, all aij are distinct) denotes the strength of a team consisting of person i and person j (people are numbered starting from 1.)
Output
Output a line containing 2n numbers. The i-th number should represent the number of teammate of i-th person.
Examples
Input
2
6
1 2
3 4 5
Output
2 1 4 3
Input
3
487060
3831 161856
845957 794650 976977
83847 50566 691206 498447
698377 156232 59015 382455 626960
Output
6 5 4 3 2 1
Note
In the first sample, contestant 1 and 2 will be teammates and so do contestant 3 and 4, so the teammate of contestant 1, 2, 3, 4 will be 2, 1, 4, 3 respectively.
Submitted Solution:
```
n = int(input())
s = []
for x in range (0, 2*n -1):
s.append(input().split())
f = []
for p in range (0,2*n):
f.append(0)
for z in range (0, 2*n*n-n):
a = 0
b = 0
c = 0
for x in range (0, len(s)):
for y in range (0,len(s[x])):
if int(s[x][y]) > a:
a = int(s[x][y])
b = x
c = y
if f[b+1] == 0 and f[c] == 0:
f[b+1] = c+1
f[c] = b+2
s[b][c] = "0"
for t in range (0,len(s[b])):
if s[b][t] != 0:
s[b][t] = 0
z = z-1
g = str(f[0])
for m in range (1, 2*n):
g = g + " " + str(f[m])
print(g)
``` | instruction | 0 | 71,197 | 17 | 142,394 |
No | output | 1 | 71,197 | 17 | 142,395 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a programing contest named SnakeUp, 2n people want to compete for it. In order to attend this contest, people need to form teams of exactly two people. You are given the strength of each possible combination of two people. All the values of the strengths are distinct.
Every contestant hopes that he can find a teammate so that their team’s strength is as high as possible. That is, a contestant will form a team with highest strength possible by choosing a teammate from ones who are willing to be a teammate with him/her. More formally, two people A and B may form a team if each of them is the best possible teammate (among the contestants that remain unpaired) for the other one.
Can you determine who will be each person’s teammate?
Input
There are 2n lines in the input.
The first line contains an integer n (1 ≤ n ≤ 400) — the number of teams to be formed.
The i-th line (i > 1) contains i - 1 numbers ai1, ai2, ... , ai(i - 1). Here aij (1 ≤ aij ≤ 106, all aij are distinct) denotes the strength of a team consisting of person i and person j (people are numbered starting from 1.)
Output
Output a line containing 2n numbers. The i-th number should represent the number of teammate of i-th person.
Examples
Input
2
6
1 2
3 4 5
Output
2 1 4 3
Input
3
487060
3831 161856
845957 794650 976977
83847 50566 691206 498447
698377 156232 59015 382455 626960
Output
6 5 4 3 2 1
Note
In the first sample, contestant 1 and 2 will be teammates and so do contestant 3 and 4, so the teammate of contestant 1, 2, 3, 4 will be 2, 1, 4, 3 respectively.
Submitted Solution:
```
n = int(input())
s = []
for x in range (0, 2*n -1):
s.append(input().split())
f = []
for p in range (0,2*n):
f.append(0)
for z in range (0, 2*n*n-n):
a = 0
b = 0
c = 0
for x in range (0, len(s)):
for y in range (0,len(s[x])):
if int(s[x][y]) > a:
a = int(s[x][y])
b = x
c = y
if f[b+1] == 0 and f[c] == 0:
f[b+1] = c+1
f[c] = b+2
s[b][c] = "0"
for t in range (0,len(s[b])):
if s[b][t] != "0":
s[b][t] = "0"
z = z-1
g = str(f[0])
for m in range (1, 2*n):
g = g + " " + str(f[m])
print(g)
``` | instruction | 0 | 71,198 | 17 | 142,396 |
No | output | 1 | 71,198 | 17 | 142,397 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.