message stringlengths 2 65.1k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 0 108k | cluster float64 14 14 | __index_level_0__ int64 0 217k |
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
Berland National Library has recently been built in the capital of Berland. In addition, in the library you can take any of the collected works of Berland leaders, the library has a reading room.
Today was the pilot launch of an automated reading room visitors' accounting system! The scanner of the system is installed at the entrance to the reading room. It records the events of the form "reader entered room", "reader left room". Every reader is assigned a registration number during the registration procedure at the library — it's a unique integer from 1 to 106. Thus, the system logs events of two forms:
* "+ ri" — the reader with registration number ri entered the room;
* "- ri" — the reader with registration number ri left the room.
The first launch of the system was a success, it functioned for some period of time, and, at the time of its launch and at the time of its shutdown, the reading room may already have visitors.
Significant funds of the budget of Berland have been spent on the design and installation of the system. Therefore, some of the citizens of the capital now demand to explain the need for this system and the benefits that its implementation will bring. Now, the developers of the system need to urgently come up with reasons for its existence.
Help the system developers to find the minimum possible capacity of the reading room (in visitors) using the log of the system available to you.
Input
The first line contains a positive integer n (1 ≤ n ≤ 100) — the number of records in the system log. Next follow n events from the system journal in the order in which the were made. Each event was written on a single line and looks as "+ ri" or "- ri", where ri is an integer from 1 to 106, the registration number of the visitor (that is, distinct visitors always have distinct registration numbers).
It is guaranteed that the log is not contradictory, that is, for every visitor the types of any of his two consecutive events are distinct. Before starting the system, and after stopping the room may possibly contain visitors.
Output
Print a single integer — the minimum possible capacity of the reading room.
Examples
Input
6
+ 12001
- 12001
- 1
- 1200
+ 1
+ 7
Output
3
Input
2
- 1
- 2
Output
2
Input
2
+ 1
- 1
Output
1
Note
In the first sample test, the system log will ensure that at some point in the reading room were visitors with registration numbers 1, 1200 and 12001. More people were not in the room at the same time based on the log. Therefore, the answer to the test is 3. | instruction | 0 | 77,121 | 14 | 154,242 |
Tags: implementation
Correct Solution:
```
n = int(input())
l = [0] * (10 ** 6 + 1)
capacity = 0
cur = 0
for i in range(n):
s = input().split()
visitor = int(s[1])
if s[0] == "+":
l[visitor] = 1
cur += 1
if cur > capacity:
capacity = cur
else:
if l[visitor] == 0:
capacity += 1
else:
l[visitor] = 0
cur -= 1
print (capacity)
``` | output | 1 | 77,121 | 14 | 154,243 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Berland National Library has recently been built in the capital of Berland. In addition, in the library you can take any of the collected works of Berland leaders, the library has a reading room.
Today was the pilot launch of an automated reading room visitors' accounting system! The scanner of the system is installed at the entrance to the reading room. It records the events of the form "reader entered room", "reader left room". Every reader is assigned a registration number during the registration procedure at the library — it's a unique integer from 1 to 106. Thus, the system logs events of two forms:
* "+ ri" — the reader with registration number ri entered the room;
* "- ri" — the reader with registration number ri left the room.
The first launch of the system was a success, it functioned for some period of time, and, at the time of its launch and at the time of its shutdown, the reading room may already have visitors.
Significant funds of the budget of Berland have been spent on the design and installation of the system. Therefore, some of the citizens of the capital now demand to explain the need for this system and the benefits that its implementation will bring. Now, the developers of the system need to urgently come up with reasons for its existence.
Help the system developers to find the minimum possible capacity of the reading room (in visitors) using the log of the system available to you.
Input
The first line contains a positive integer n (1 ≤ n ≤ 100) — the number of records in the system log. Next follow n events from the system journal in the order in which the were made. Each event was written on a single line and looks as "+ ri" or "- ri", where ri is an integer from 1 to 106, the registration number of the visitor (that is, distinct visitors always have distinct registration numbers).
It is guaranteed that the log is not contradictory, that is, for every visitor the types of any of his two consecutive events are distinct. Before starting the system, and after stopping the room may possibly contain visitors.
Output
Print a single integer — the minimum possible capacity of the reading room.
Examples
Input
6
+ 12001
- 12001
- 1
- 1200
+ 1
+ 7
Output
3
Input
2
- 1
- 2
Output
2
Input
2
+ 1
- 1
Output
1
Note
In the first sample test, the system log will ensure that at some point in the reading room were visitors with registration numbers 1, 1200 and 12001. More people were not in the room at the same time based on the log. Therefore, the answer to the test is 3. | instruction | 0 | 77,122 | 14 | 154,244 |
Tags: implementation
Correct Solution:
```
d=set()
m=0
for _ in range(int(input())):
x,i=input().split()
if x=="-":
if i in d:d.remove(i)
else:m+=1
else: d.add(i)
m=max(m,len(d))
print(m)
# Made By Mostafa_Khaled
``` | output | 1 | 77,122 | 14 | 154,245 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Berland National Library has recently been built in the capital of Berland. In addition, in the library you can take any of the collected works of Berland leaders, the library has a reading room.
Today was the pilot launch of an automated reading room visitors' accounting system! The scanner of the system is installed at the entrance to the reading room. It records the events of the form "reader entered room", "reader left room". Every reader is assigned a registration number during the registration procedure at the library — it's a unique integer from 1 to 106. Thus, the system logs events of two forms:
* "+ ri" — the reader with registration number ri entered the room;
* "- ri" — the reader with registration number ri left the room.
The first launch of the system was a success, it functioned for some period of time, and, at the time of its launch and at the time of its shutdown, the reading room may already have visitors.
Significant funds of the budget of Berland have been spent on the design and installation of the system. Therefore, some of the citizens of the capital now demand to explain the need for this system and the benefits that its implementation will bring. Now, the developers of the system need to urgently come up with reasons for its existence.
Help the system developers to find the minimum possible capacity of the reading room (in visitors) using the log of the system available to you.
Input
The first line contains a positive integer n (1 ≤ n ≤ 100) — the number of records in the system log. Next follow n events from the system journal in the order in which the were made. Each event was written on a single line and looks as "+ ri" or "- ri", where ri is an integer from 1 to 106, the registration number of the visitor (that is, distinct visitors always have distinct registration numbers).
It is guaranteed that the log is not contradictory, that is, for every visitor the types of any of his two consecutive events are distinct. Before starting the system, and after stopping the room may possibly contain visitors.
Output
Print a single integer — the minimum possible capacity of the reading room.
Examples
Input
6
+ 12001
- 12001
- 1
- 1200
+ 1
+ 7
Output
3
Input
2
- 1
- 2
Output
2
Input
2
+ 1
- 1
Output
1
Note
In the first sample test, the system log will ensure that at some point in the reading room were visitors with registration numbers 1, 1200 and 12001. More people were not in the room at the same time based on the log. Therefore, the answer to the test is 3. | instruction | 0 | 77,123 | 14 | 154,246 |
Tags: implementation
Correct Solution:
```
def main():
n = int(input())
prev = set()
min_cap = 0
cap = 0
for _ in range(n):
cur = input().split()
is_in = cur[0] == '+'
idx = int(cur[1])
if is_in:
cap += 1
prev.add(idx)
min_cap = max(cap, min_cap)
else:
if idx not in prev:
min_cap += 1
prev.add(idx)
else:
cap -= 1
print(min_cap)
if __name__ == '__main__':
main()
``` | output | 1 | 77,123 | 14 | 154,247 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Berland National Library has recently been built in the capital of Berland. In addition, in the library you can take any of the collected works of Berland leaders, the library has a reading room.
Today was the pilot launch of an automated reading room visitors' accounting system! The scanner of the system is installed at the entrance to the reading room. It records the events of the form "reader entered room", "reader left room". Every reader is assigned a registration number during the registration procedure at the library — it's a unique integer from 1 to 106. Thus, the system logs events of two forms:
* "+ ri" — the reader with registration number ri entered the room;
* "- ri" — the reader with registration number ri left the room.
The first launch of the system was a success, it functioned for some period of time, and, at the time of its launch and at the time of its shutdown, the reading room may already have visitors.
Significant funds of the budget of Berland have been spent on the design and installation of the system. Therefore, some of the citizens of the capital now demand to explain the need for this system and the benefits that its implementation will bring. Now, the developers of the system need to urgently come up with reasons for its existence.
Help the system developers to find the minimum possible capacity of the reading room (in visitors) using the log of the system available to you.
Input
The first line contains a positive integer n (1 ≤ n ≤ 100) — the number of records in the system log. Next follow n events from the system journal in the order in which the were made. Each event was written on a single line and looks as "+ ri" or "- ri", where ri is an integer from 1 to 106, the registration number of the visitor (that is, distinct visitors always have distinct registration numbers).
It is guaranteed that the log is not contradictory, that is, for every visitor the types of any of his two consecutive events are distinct. Before starting the system, and after stopping the room may possibly contain visitors.
Output
Print a single integer — the minimum possible capacity of the reading room.
Examples
Input
6
+ 12001
- 12001
- 1
- 1200
+ 1
+ 7
Output
3
Input
2
- 1
- 2
Output
2
Input
2
+ 1
- 1
Output
1
Note
In the first sample test, the system log will ensure that at some point in the reading room were visitors with registration numbers 1, 1200 and 12001. More people were not in the room at the same time based on the log. Therefore, the answer to the test is 3. | instruction | 0 | 77,124 | 14 | 154,248 |
Tags: implementation
Correct Solution:
```
n = int(input())
a = [0] * (n+1)
b = [[0,0]] * (n+1)
for i in range(1,n+1):
s = list(map(str,input().split()))
b[i] = s
if (s[0] == '+'):
a[i] = a[i-1] + 1
else:
j = i
c1 = 0
while (j >= 0):
if ((b[j][0] == '+') and (b[j][1] == b[i][1])):
c1 = -1
break
j = j - 1
if (c1 != -1):
for j in range(0,i+1):
a[j] = a[j] + 1
if (a[i-1] == 0):
a[i] = 0
else:
a[i] = a[i-1] - 1
print(max(a))
``` | output | 1 | 77,124 | 14 | 154,249 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Berland National Library has recently been built in the capital of Berland. In addition, in the library you can take any of the collected works of Berland leaders, the library has a reading room.
Today was the pilot launch of an automated reading room visitors' accounting system! The scanner of the system is installed at the entrance to the reading room. It records the events of the form "reader entered room", "reader left room". Every reader is assigned a registration number during the registration procedure at the library — it's a unique integer from 1 to 106. Thus, the system logs events of two forms:
* "+ ri" — the reader with registration number ri entered the room;
* "- ri" — the reader with registration number ri left the room.
The first launch of the system was a success, it functioned for some period of time, and, at the time of its launch and at the time of its shutdown, the reading room may already have visitors.
Significant funds of the budget of Berland have been spent on the design and installation of the system. Therefore, some of the citizens of the capital now demand to explain the need for this system and the benefits that its implementation will bring. Now, the developers of the system need to urgently come up with reasons for its existence.
Help the system developers to find the minimum possible capacity of the reading room (in visitors) using the log of the system available to you.
Input
The first line contains a positive integer n (1 ≤ n ≤ 100) — the number of records in the system log. Next follow n events from the system journal in the order in which the were made. Each event was written on a single line and looks as "+ ri" or "- ri", where ri is an integer from 1 to 106, the registration number of the visitor (that is, distinct visitors always have distinct registration numbers).
It is guaranteed that the log is not contradictory, that is, for every visitor the types of any of his two consecutive events are distinct. Before starting the system, and after stopping the room may possibly contain visitors.
Output
Print a single integer — the minimum possible capacity of the reading room.
Examples
Input
6
+ 12001
- 12001
- 1
- 1200
+ 1
+ 7
Output
3
Input
2
- 1
- 2
Output
2
Input
2
+ 1
- 1
Output
1
Note
In the first sample test, the system log will ensure that at some point in the reading room were visitors with registration numbers 1, 1200 and 12001. More people were not in the room at the same time based on the log. Therefore, the answer to the test is 3. | instruction | 0 | 77,125 | 14 | 154,250 |
Tags: implementation
Correct Solution:
```
count = 0
ans = 0
a = set()
n = int(input())
for i in range(n):
reg = input().split()
reg[1] = int(reg[1])
if reg[0] == '+':
a.add(reg[1])
count += 1
else:
if reg[1] in a:
a.remove(reg[1])
count -= 1
else:
ans += 1
if count > ans:
ans = count
print(ans)
``` | output | 1 | 77,125 | 14 | 154,251 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Berland National Library has recently been built in the capital of Berland. In addition, in the library you can take any of the collected works of Berland leaders, the library has a reading room.
Today was the pilot launch of an automated reading room visitors' accounting system! The scanner of the system is installed at the entrance to the reading room. It records the events of the form "reader entered room", "reader left room". Every reader is assigned a registration number during the registration procedure at the library — it's a unique integer from 1 to 106. Thus, the system logs events of two forms:
* "+ ri" — the reader with registration number ri entered the room;
* "- ri" — the reader with registration number ri left the room.
The first launch of the system was a success, it functioned for some period of time, and, at the time of its launch and at the time of its shutdown, the reading room may already have visitors.
Significant funds of the budget of Berland have been spent on the design and installation of the system. Therefore, some of the citizens of the capital now demand to explain the need for this system and the benefits that its implementation will bring. Now, the developers of the system need to urgently come up with reasons for its existence.
Help the system developers to find the minimum possible capacity of the reading room (in visitors) using the log of the system available to you.
Input
The first line contains a positive integer n (1 ≤ n ≤ 100) — the number of records in the system log. Next follow n events from the system journal in the order in which the were made. Each event was written on a single line and looks as "+ ri" or "- ri", where ri is an integer from 1 to 106, the registration number of the visitor (that is, distinct visitors always have distinct registration numbers).
It is guaranteed that the log is not contradictory, that is, for every visitor the types of any of his two consecutive events are distinct. Before starting the system, and after stopping the room may possibly contain visitors.
Output
Print a single integer — the minimum possible capacity of the reading room.
Examples
Input
6
+ 12001
- 12001
- 1
- 1200
+ 1
+ 7
Output
3
Input
2
- 1
- 2
Output
2
Input
2
+ 1
- 1
Output
1
Note
In the first sample test, the system log will ensure that at some point in the reading room were visitors with registration numbers 1, 1200 and 12001. More people were not in the room at the same time based on the log. Therefore, the answer to the test is 3. | instruction | 0 | 77,126 | 14 | 154,252 |
Tags: implementation
Correct Solution:
```
n = int(input())
# start_count = 0
max_count = 0
lib = []
for i in range(0, n):
sign, key = input().split()
if sign == '+':
lib.append(key)
if len(lib) > max_count:
max_count = len(lib)
else:
if lib.count(key) > 0:
lib.remove(key)
else:
# start_count += 1
max_count += 1
print(max_count)
``` | output | 1 | 77,126 | 14 | 154,253 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Berland National Library has recently been built in the capital of Berland. In addition, in the library you can take any of the collected works of Berland leaders, the library has a reading room.
Today was the pilot launch of an automated reading room visitors' accounting system! The scanner of the system is installed at the entrance to the reading room. It records the events of the form "reader entered room", "reader left room". Every reader is assigned a registration number during the registration procedure at the library — it's a unique integer from 1 to 106. Thus, the system logs events of two forms:
* "+ ri" — the reader with registration number ri entered the room;
* "- ri" — the reader with registration number ri left the room.
The first launch of the system was a success, it functioned for some period of time, and, at the time of its launch and at the time of its shutdown, the reading room may already have visitors.
Significant funds of the budget of Berland have been spent on the design and installation of the system. Therefore, some of the citizens of the capital now demand to explain the need for this system and the benefits that its implementation will bring. Now, the developers of the system need to urgently come up with reasons for its existence.
Help the system developers to find the minimum possible capacity of the reading room (in visitors) using the log of the system available to you.
Input
The first line contains a positive integer n (1 ≤ n ≤ 100) — the number of records in the system log. Next follow n events from the system journal in the order in which the were made. Each event was written on a single line and looks as "+ ri" or "- ri", where ri is an integer from 1 to 106, the registration number of the visitor (that is, distinct visitors always have distinct registration numbers).
It is guaranteed that the log is not contradictory, that is, for every visitor the types of any of his two consecutive events are distinct. Before starting the system, and after stopping the room may possibly contain visitors.
Output
Print a single integer — the minimum possible capacity of the reading room.
Examples
Input
6
+ 12001
- 12001
- 1
- 1200
+ 1
+ 7
Output
3
Input
2
- 1
- 2
Output
2
Input
2
+ 1
- 1
Output
1
Note
In the first sample test, the system log will ensure that at some point in the reading room were visitors with registration numbers 1, 1200 and 12001. More people were not in the room at the same time based on the log. Therefore, the answer to the test is 3.
Submitted Solution:
```
#!/usr/bin/env python3
N = int(input())
room = set()
max_occupancy = 0
for _ in range(N):
command, uid = input().split()
uid = int(uid)
if command == '+': room.add(uid)
if command == '-':
if uid not in room:
room.add(uid)
max_occupancy += 1
room.remove(uid)
max_occupancy = max(max_occupancy, len(room))
print(max_occupancy)
``` | instruction | 0 | 77,127 | 14 | 154,254 |
Yes | output | 1 | 77,127 | 14 | 154,255 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Berland National Library has recently been built in the capital of Berland. In addition, in the library you can take any of the collected works of Berland leaders, the library has a reading room.
Today was the pilot launch of an automated reading room visitors' accounting system! The scanner of the system is installed at the entrance to the reading room. It records the events of the form "reader entered room", "reader left room". Every reader is assigned a registration number during the registration procedure at the library — it's a unique integer from 1 to 106. Thus, the system logs events of two forms:
* "+ ri" — the reader with registration number ri entered the room;
* "- ri" — the reader with registration number ri left the room.
The first launch of the system was a success, it functioned for some period of time, and, at the time of its launch and at the time of its shutdown, the reading room may already have visitors.
Significant funds of the budget of Berland have been spent on the design and installation of the system. Therefore, some of the citizens of the capital now demand to explain the need for this system and the benefits that its implementation will bring. Now, the developers of the system need to urgently come up with reasons for its existence.
Help the system developers to find the minimum possible capacity of the reading room (in visitors) using the log of the system available to you.
Input
The first line contains a positive integer n (1 ≤ n ≤ 100) — the number of records in the system log. Next follow n events from the system journal in the order in which the were made. Each event was written on a single line and looks as "+ ri" or "- ri", where ri is an integer from 1 to 106, the registration number of the visitor (that is, distinct visitors always have distinct registration numbers).
It is guaranteed that the log is not contradictory, that is, for every visitor the types of any of his two consecutive events are distinct. Before starting the system, and after stopping the room may possibly contain visitors.
Output
Print a single integer — the minimum possible capacity of the reading room.
Examples
Input
6
+ 12001
- 12001
- 1
- 1200
+ 1
+ 7
Output
3
Input
2
- 1
- 2
Output
2
Input
2
+ 1
- 1
Output
1
Note
In the first sample test, the system log will ensure that at some point in the reading room were visitors with registration numbers 1, 1200 and 12001. More people were not in the room at the same time based on the log. Therefore, the answer to the test is 3.
Submitted Solution:
```
import sys
count = 0
def func(s_list):
dic = {}
room_set = set()
room_num = 0
max = 0
for tmp in s_list:
s1 = tmp.strip().split(' ')[0]
s2 = tmp.strip().split(' ')[1]
if s1 == '-':
dic[s2] = dic.get(s2, 0) - 1
if dic[s2] < 0:
room_set.add(s2)
else:
dic[s2] = dic.get(s2, 0) + 1
for k, v in dic.items():
if v < 0:
room_set.add(k)
room_num = len(room_set)
max = room_num
for tmp in s_list:
s1 = tmp.strip().split(' ')[0]
s2 = tmp.strip().split(' ')[1]
if s1 == '-':
room_num -= 1
else:
room_num += 1
if room_num > max:
max = room_num
return max
s_list = []
for line in sys.stdin:
if count == 0:
num_tmp = int(line.strip())
count += 1
continue
s_list.append(line.strip())
print(func(s_list))
``` | instruction | 0 | 77,128 | 14 | 154,256 |
Yes | output | 1 | 77,128 | 14 | 154,257 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Berland National Library has recently been built in the capital of Berland. In addition, in the library you can take any of the collected works of Berland leaders, the library has a reading room.
Today was the pilot launch of an automated reading room visitors' accounting system! The scanner of the system is installed at the entrance to the reading room. It records the events of the form "reader entered room", "reader left room". Every reader is assigned a registration number during the registration procedure at the library — it's a unique integer from 1 to 106. Thus, the system logs events of two forms:
* "+ ri" — the reader with registration number ri entered the room;
* "- ri" — the reader with registration number ri left the room.
The first launch of the system was a success, it functioned for some period of time, and, at the time of its launch and at the time of its shutdown, the reading room may already have visitors.
Significant funds of the budget of Berland have been spent on the design and installation of the system. Therefore, some of the citizens of the capital now demand to explain the need for this system and the benefits that its implementation will bring. Now, the developers of the system need to urgently come up with reasons for its existence.
Help the system developers to find the minimum possible capacity of the reading room (in visitors) using the log of the system available to you.
Input
The first line contains a positive integer n (1 ≤ n ≤ 100) — the number of records in the system log. Next follow n events from the system journal in the order in which the were made. Each event was written on a single line and looks as "+ ri" or "- ri", where ri is an integer from 1 to 106, the registration number of the visitor (that is, distinct visitors always have distinct registration numbers).
It is guaranteed that the log is not contradictory, that is, for every visitor the types of any of his two consecutive events are distinct. Before starting the system, and after stopping the room may possibly contain visitors.
Output
Print a single integer — the minimum possible capacity of the reading room.
Examples
Input
6
+ 12001
- 12001
- 1
- 1200
+ 1
+ 7
Output
3
Input
2
- 1
- 2
Output
2
Input
2
+ 1
- 1
Output
1
Note
In the first sample test, the system log will ensure that at some point in the reading room were visitors with registration numbers 1, 1200 and 12001. More people were not in the room at the same time based on the log. Therefore, the answer to the test is 3.
Submitted Solution:
```
a=int(input())
x=[]
y=[]
mx=0
for i in range(a):
aw=input().split()
x.append(aw[0])
y.append(aw[1])
people=set()
for i in range(a):
if x[i]=='-':
if y[i] in people:
people.remove(y[i])
else:
mx+=1
elif x[i]=='+':
people.add(y[i])
mx=max(mx,len(people))
print(mx)
``` | instruction | 0 | 77,129 | 14 | 154,258 |
Yes | output | 1 | 77,129 | 14 | 154,259 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Berland National Library has recently been built in the capital of Berland. In addition, in the library you can take any of the collected works of Berland leaders, the library has a reading room.
Today was the pilot launch of an automated reading room visitors' accounting system! The scanner of the system is installed at the entrance to the reading room. It records the events of the form "reader entered room", "reader left room". Every reader is assigned a registration number during the registration procedure at the library — it's a unique integer from 1 to 106. Thus, the system logs events of two forms:
* "+ ri" — the reader with registration number ri entered the room;
* "- ri" — the reader with registration number ri left the room.
The first launch of the system was a success, it functioned for some period of time, and, at the time of its launch and at the time of its shutdown, the reading room may already have visitors.
Significant funds of the budget of Berland have been spent on the design and installation of the system. Therefore, some of the citizens of the capital now demand to explain the need for this system and the benefits that its implementation will bring. Now, the developers of the system need to urgently come up with reasons for its existence.
Help the system developers to find the minimum possible capacity of the reading room (in visitors) using the log of the system available to you.
Input
The first line contains a positive integer n (1 ≤ n ≤ 100) — the number of records in the system log. Next follow n events from the system journal in the order in which the were made. Each event was written on a single line and looks as "+ ri" or "- ri", where ri is an integer from 1 to 106, the registration number of the visitor (that is, distinct visitors always have distinct registration numbers).
It is guaranteed that the log is not contradictory, that is, for every visitor the types of any of his two consecutive events are distinct. Before starting the system, and after stopping the room may possibly contain visitors.
Output
Print a single integer — the minimum possible capacity of the reading room.
Examples
Input
6
+ 12001
- 12001
- 1
- 1200
+ 1
+ 7
Output
3
Input
2
- 1
- 2
Output
2
Input
2
+ 1
- 1
Output
1
Note
In the first sample test, the system log will ensure that at some point in the reading room were visitors with registration numbers 1, 1200 and 12001. More people were not in the room at the same time based on the log. Therefore, the answer to the test is 3.
Submitted Solution:
```
n,l,m,a=int(input()),[0]*1000000,0,[]
for _ in range(n):a.append(input())
for i in range(n):
if a[i][0]=='+':l[int(a[i][2:])-1]=1
elif not l[int(a[i][2:])-1]:m+=1
ans=m
for i in range(n):
if a[i][0]=='+':m+=1;ans=max(m,ans)
else:m-=1
print(ans)
``` | instruction | 0 | 77,130 | 14 | 154,260 |
Yes | output | 1 | 77,130 | 14 | 154,261 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Berland National Library has recently been built in the capital of Berland. In addition, in the library you can take any of the collected works of Berland leaders, the library has a reading room.
Today was the pilot launch of an automated reading room visitors' accounting system! The scanner of the system is installed at the entrance to the reading room. It records the events of the form "reader entered room", "reader left room". Every reader is assigned a registration number during the registration procedure at the library — it's a unique integer from 1 to 106. Thus, the system logs events of two forms:
* "+ ri" — the reader with registration number ri entered the room;
* "- ri" — the reader with registration number ri left the room.
The first launch of the system was a success, it functioned for some period of time, and, at the time of its launch and at the time of its shutdown, the reading room may already have visitors.
Significant funds of the budget of Berland have been spent on the design and installation of the system. Therefore, some of the citizens of the capital now demand to explain the need for this system and the benefits that its implementation will bring. Now, the developers of the system need to urgently come up with reasons for its existence.
Help the system developers to find the minimum possible capacity of the reading room (in visitors) using the log of the system available to you.
Input
The first line contains a positive integer n (1 ≤ n ≤ 100) — the number of records in the system log. Next follow n events from the system journal in the order in which the were made. Each event was written on a single line and looks as "+ ri" or "- ri", where ri is an integer from 1 to 106, the registration number of the visitor (that is, distinct visitors always have distinct registration numbers).
It is guaranteed that the log is not contradictory, that is, for every visitor the types of any of his two consecutive events are distinct. Before starting the system, and after stopping the room may possibly contain visitors.
Output
Print a single integer — the minimum possible capacity of the reading room.
Examples
Input
6
+ 12001
- 12001
- 1
- 1200
+ 1
+ 7
Output
3
Input
2
- 1
- 2
Output
2
Input
2
+ 1
- 1
Output
1
Note
In the first sample test, the system log will ensure that at some point in the reading room were visitors with registration numbers 1, 1200 and 12001. More people were not in the room at the same time based on the log. Therefore, the answer to the test is 3.
Submitted Solution:
```
n = int(input())
ori = []
for i in range(n):
ori.append(input())
max = 0
def cal(ll):
temp = []
for i in ll:
if i[0] == "-":
temp.append(i[1:])
if i[0] == "+" and i[1:] in temp:
temp.remove(i[1:])
return len(temp)
cur = 0
max = 0
for i in range(len(ori)):
if ori[i][0] == "-":
cur = cal(ori[i:]) - 1
else:
cur = cal(ori[i:]) + 1
if cur > max:
max = cur
print(max)
``` | instruction | 0 | 77,131 | 14 | 154,262 |
No | output | 1 | 77,131 | 14 | 154,263 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Berland National Library has recently been built in the capital of Berland. In addition, in the library you can take any of the collected works of Berland leaders, the library has a reading room.
Today was the pilot launch of an automated reading room visitors' accounting system! The scanner of the system is installed at the entrance to the reading room. It records the events of the form "reader entered room", "reader left room". Every reader is assigned a registration number during the registration procedure at the library — it's a unique integer from 1 to 106. Thus, the system logs events of two forms:
* "+ ri" — the reader with registration number ri entered the room;
* "- ri" — the reader with registration number ri left the room.
The first launch of the system was a success, it functioned for some period of time, and, at the time of its launch and at the time of its shutdown, the reading room may already have visitors.
Significant funds of the budget of Berland have been spent on the design and installation of the system. Therefore, some of the citizens of the capital now demand to explain the need for this system and the benefits that its implementation will bring. Now, the developers of the system need to urgently come up with reasons for its existence.
Help the system developers to find the minimum possible capacity of the reading room (in visitors) using the log of the system available to you.
Input
The first line contains a positive integer n (1 ≤ n ≤ 100) — the number of records in the system log. Next follow n events from the system journal in the order in which the were made. Each event was written on a single line and looks as "+ ri" or "- ri", where ri is an integer from 1 to 106, the registration number of the visitor (that is, distinct visitors always have distinct registration numbers).
It is guaranteed that the log is not contradictory, that is, for every visitor the types of any of his two consecutive events are distinct. Before starting the system, and after stopping the room may possibly contain visitors.
Output
Print a single integer — the minimum possible capacity of the reading room.
Examples
Input
6
+ 12001
- 12001
- 1
- 1200
+ 1
+ 7
Output
3
Input
2
- 1
- 2
Output
2
Input
2
+ 1
- 1
Output
1
Note
In the first sample test, the system log will ensure that at some point in the reading room were visitors with registration numbers 1, 1200 and 12001. More people were not in the room at the same time based on the log. Therefore, the answer to the test is 3.
Submitted Solution:
```
n = int(input())
people = []
current = 0
num = [0]
for i in range(n):
x, y = input().split()
if x == "+":
people.append(y)
current += 1
num.append(current)
else:
try:
people.remove(y)
except:
pass
current -= 1
num.append(current)
num = [*map(lambda x : x - min(num + [0]), num)]
print(max(num))
``` | instruction | 0 | 77,132 | 14 | 154,264 |
No | output | 1 | 77,132 | 14 | 154,265 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Berland National Library has recently been built in the capital of Berland. In addition, in the library you can take any of the collected works of Berland leaders, the library has a reading room.
Today was the pilot launch of an automated reading room visitors' accounting system! The scanner of the system is installed at the entrance to the reading room. It records the events of the form "reader entered room", "reader left room". Every reader is assigned a registration number during the registration procedure at the library — it's a unique integer from 1 to 106. Thus, the system logs events of two forms:
* "+ ri" — the reader with registration number ri entered the room;
* "- ri" — the reader with registration number ri left the room.
The first launch of the system was a success, it functioned for some period of time, and, at the time of its launch and at the time of its shutdown, the reading room may already have visitors.
Significant funds of the budget of Berland have been spent on the design and installation of the system. Therefore, some of the citizens of the capital now demand to explain the need for this system and the benefits that its implementation will bring. Now, the developers of the system need to urgently come up with reasons for its existence.
Help the system developers to find the minimum possible capacity of the reading room (in visitors) using the log of the system available to you.
Input
The first line contains a positive integer n (1 ≤ n ≤ 100) — the number of records in the system log. Next follow n events from the system journal in the order in which the were made. Each event was written on a single line and looks as "+ ri" or "- ri", where ri is an integer from 1 to 106, the registration number of the visitor (that is, distinct visitors always have distinct registration numbers).
It is guaranteed that the log is not contradictory, that is, for every visitor the types of any of his two consecutive events are distinct. Before starting the system, and after stopping the room may possibly contain visitors.
Output
Print a single integer — the minimum possible capacity of the reading room.
Examples
Input
6
+ 12001
- 12001
- 1
- 1200
+ 1
+ 7
Output
3
Input
2
- 1
- 2
Output
2
Input
2
+ 1
- 1
Output
1
Note
In the first sample test, the system log will ensure that at some point in the reading room were visitors with registration numbers 1, 1200 and 12001. More people were not in the room at the same time based on the log. Therefore, the answer to the test is 3.
Submitted Solution:
```
lines = int(input())
x = 0
room = []
personNo = 0
statusList = []
leastNo = 0
mostNo = 0
for i in range(lines):
strs = input()
if "+" in strs:
room.append(strs.split(" "))
personNo = personNo + 1
else:
personNo = personNo - 1
if personNo < leastNo:
leastNo = personNo
if personNo > mostNo:
mostNo = personNo
print (mostNo - leastNo)
``` | instruction | 0 | 77,133 | 14 | 154,266 |
No | output | 1 | 77,133 | 14 | 154,267 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Berland National Library has recently been built in the capital of Berland. In addition, in the library you can take any of the collected works of Berland leaders, the library has a reading room.
Today was the pilot launch of an automated reading room visitors' accounting system! The scanner of the system is installed at the entrance to the reading room. It records the events of the form "reader entered room", "reader left room". Every reader is assigned a registration number during the registration procedure at the library — it's a unique integer from 1 to 106. Thus, the system logs events of two forms:
* "+ ri" — the reader with registration number ri entered the room;
* "- ri" — the reader with registration number ri left the room.
The first launch of the system was a success, it functioned for some period of time, and, at the time of its launch and at the time of its shutdown, the reading room may already have visitors.
Significant funds of the budget of Berland have been spent on the design and installation of the system. Therefore, some of the citizens of the capital now demand to explain the need for this system and the benefits that its implementation will bring. Now, the developers of the system need to urgently come up with reasons for its existence.
Help the system developers to find the minimum possible capacity of the reading room (in visitors) using the log of the system available to you.
Input
The first line contains a positive integer n (1 ≤ n ≤ 100) — the number of records in the system log. Next follow n events from the system journal in the order in which the were made. Each event was written on a single line and looks as "+ ri" or "- ri", where ri is an integer from 1 to 106, the registration number of the visitor (that is, distinct visitors always have distinct registration numbers).
It is guaranteed that the log is not contradictory, that is, for every visitor the types of any of his two consecutive events are distinct. Before starting the system, and after stopping the room may possibly contain visitors.
Output
Print a single integer — the minimum possible capacity of the reading room.
Examples
Input
6
+ 12001
- 12001
- 1
- 1200
+ 1
+ 7
Output
3
Input
2
- 1
- 2
Output
2
Input
2
+ 1
- 1
Output
1
Note
In the first sample test, the system log will ensure that at some point in the reading room were visitors with registration numbers 1, 1200 and 12001. More people were not in the room at the same time based on the log. Therefore, the answer to the test is 3.
Submitted Solution:
```
N = int(input())
data = []
for i in range(N):
data.append(input().strip())
res = 0
tmp_exist = {}
for i in range(N):
if data[i][0] == '+':
tmp_exist[data[i]] = 1
if data[i][0] == '-':
if "+" + data[i][1:] not in tmp_exist:
res += 1
tmp = {}
tmp_res = res
#print(res,tmp_exist)
for i in range(N):
if data[i][0] == '+':
if data[i] in tmp_exist or data[i] in tmp:
continue
tmp_res += 1
if tmp_res > res:
res = tmp_res
tmp[data[i]] = 1
elif data[i][0] == '-':
if "+" + data[i][1:] in tmp or "+" + data[i][1:] in tmp_exist:
tmp_res -= 1
#print(data[i],tmp_res)
if tmp_res > res:
res = tmp_res
print(res)
``` | instruction | 0 | 77,134 | 14 | 154,268 |
No | output | 1 | 77,134 | 14 | 154,269 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In the army, it isn't easy to form a group of soldiers that will be effective on the battlefield. The communication is crucial and thus no two soldiers should share a name (what would happen if they got an order that Bob is a scouter, if there are two Bobs?).
A group of soldiers is effective if and only if their names are different. For example, a group (John, Bob, Limak) would be effective, while groups (Gary, Bob, Gary) and (Alice, Alice) wouldn't.
You are a spy in the enemy's camp. You noticed n soldiers standing in a row, numbered 1 through n. The general wants to choose a group of k consecutive soldiers. For every k consecutive soldiers, the general wrote down whether they would be an effective group or not.
You managed to steal the general's notes, with n - k + 1 strings s1, s2, ..., sn - k + 1, each either "YES" or "NO".
* The string s1 describes a group of soldiers 1 through k ("YES" if the group is effective, and "NO" otherwise).
* The string s2 describes a group of soldiers 2 through k + 1.
* And so on, till the string sn - k + 1 that describes a group of soldiers n - k + 1 through n.
Your task is to find possible names of n soldiers. Names should match the stolen notes. Each name should be a string that consists of between 1 and 10 English letters, inclusive. The first letter should be uppercase, and all other letters should be lowercase. Names don't have to be existing names — it's allowed to print "Xyzzzdj" or "T" for example.
Find and print any solution. It can be proved that there always exists at least one solution.
Input
The first line of the input contains two integers n and k (2 ≤ k ≤ n ≤ 50) — the number of soldiers and the size of a group respectively.
The second line contains n - k + 1 strings s1, s2, ..., sn - k + 1. The string si is "YES" if the group of soldiers i through i + k - 1 is effective, and "NO" otherwise.
Output
Find any solution satisfying all given conditions. In one line print n space-separated strings, denoting possible names of soldiers in the order. The first letter of each name should be uppercase, while the other letters should be lowercase. Each name should contain English letters only and has length from 1 to 10.
If there are multiple valid solutions, print any of them.
Examples
Input
8 3
NO NO YES YES YES NO
Output
Adam Bob Bob Cpqepqwer Limak Adam Bob Adam
Input
9 8
YES NO
Output
R Q Ccccccccc Ccocc Ccc So Strong Samples Ccc
Input
3 2
NO NO
Output
Na Na Na
Note
In the first sample, there are 8 soldiers. For every 3 consecutive ones we know whether they would be an effective group. Let's analyze the provided sample output:
* First three soldiers (i.e. Adam, Bob, Bob) wouldn't be an effective group because there are two Bobs. Indeed, the string s1 is "NO".
* Soldiers 2 through 4 (Bob, Bob, Cpqepqwer) wouldn't be effective either, and the string s2 is "NO".
* Soldiers 3 through 5 (Bob, Cpqepqwer, Limak) would be effective, and the string s3 is "YES".
* ...,
* Soldiers 6 through 8 (Adam, Bob, Adam) wouldn't be effective, and the string s6 is "NO". | instruction | 0 | 77,221 | 14 | 154,442 |
Tags: constructive algorithms, greedy
Correct Solution:
```
names = [chr(ord('A') + i) for i in range(26)]
names += ['A' + chr(ord('a') + i) for i in range(26)]
n, k = map(int, input().split())
a = input().split()
for i, a_i in enumerate(a):
if a_i == 'NO':
names[i+k-1] = names[i]
print(' '.join(names[:n]))
# Made By Mostafa_Khaled
``` | output | 1 | 77,221 | 14 | 154,443 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In the army, it isn't easy to form a group of soldiers that will be effective on the battlefield. The communication is crucial and thus no two soldiers should share a name (what would happen if they got an order that Bob is a scouter, if there are two Bobs?).
A group of soldiers is effective if and only if their names are different. For example, a group (John, Bob, Limak) would be effective, while groups (Gary, Bob, Gary) and (Alice, Alice) wouldn't.
You are a spy in the enemy's camp. You noticed n soldiers standing in a row, numbered 1 through n. The general wants to choose a group of k consecutive soldiers. For every k consecutive soldiers, the general wrote down whether they would be an effective group or not.
You managed to steal the general's notes, with n - k + 1 strings s1, s2, ..., sn - k + 1, each either "YES" or "NO".
* The string s1 describes a group of soldiers 1 through k ("YES" if the group is effective, and "NO" otherwise).
* The string s2 describes a group of soldiers 2 through k + 1.
* And so on, till the string sn - k + 1 that describes a group of soldiers n - k + 1 through n.
Your task is to find possible names of n soldiers. Names should match the stolen notes. Each name should be a string that consists of between 1 and 10 English letters, inclusive. The first letter should be uppercase, and all other letters should be lowercase. Names don't have to be existing names — it's allowed to print "Xyzzzdj" or "T" for example.
Find and print any solution. It can be proved that there always exists at least one solution.
Input
The first line of the input contains two integers n and k (2 ≤ k ≤ n ≤ 50) — the number of soldiers and the size of a group respectively.
The second line contains n - k + 1 strings s1, s2, ..., sn - k + 1. The string si is "YES" if the group of soldiers i through i + k - 1 is effective, and "NO" otherwise.
Output
Find any solution satisfying all given conditions. In one line print n space-separated strings, denoting possible names of soldiers in the order. The first letter of each name should be uppercase, while the other letters should be lowercase. Each name should contain English letters only and has length from 1 to 10.
If there are multiple valid solutions, print any of them.
Examples
Input
8 3
NO NO YES YES YES NO
Output
Adam Bob Bob Cpqepqwer Limak Adam Bob Adam
Input
9 8
YES NO
Output
R Q Ccccccccc Ccocc Ccc So Strong Samples Ccc
Input
3 2
NO NO
Output
Na Na Na
Note
In the first sample, there are 8 soldiers. For every 3 consecutive ones we know whether they would be an effective group. Let's analyze the provided sample output:
* First three soldiers (i.e. Adam, Bob, Bob) wouldn't be an effective group because there are two Bobs. Indeed, the string s1 is "NO".
* Soldiers 2 through 4 (Bob, Bob, Cpqepqwer) wouldn't be effective either, and the string s2 is "NO".
* Soldiers 3 through 5 (Bob, Cpqepqwer, Limak) would be effective, and the string s3 is "YES".
* ...,
* Soldiers 6 through 8 (Adam, Bob, Adam) wouldn't be effective, and the string s6 is "NO". | instruction | 0 | 77,222 | 14 | 154,444 |
Tags: constructive algorithms, greedy
Correct Solution:
```
n, k = map(int, input().split())
names = []
def getNext(a):
if a[1] == 'z':
return chr(ord(a[0]) + 1) + 'a'
else:
return a[0] + chr(ord(a[1]) + 1)
a = list(input().split())
for i in range(len(a)):
a[i] = 1 if a[i] == 'YES' else 0
tmp = 'Aa'
names.append(tmp)
if a[0]:
for i in range(k - 1):
tmp = getNext(tmp)
names.append(tmp)
else:
names.append(tmp)
for i in range(k - 2):
tmp = getNext(tmp)
names.append(getNext(tmp))
for i in range(k, n):
if a[i - k + 1]:
tmp = getNext(tmp)
names.append(getNext(tmp))
else:
names.append(names[i - k + 1])
print(*names)
``` | output | 1 | 77,222 | 14 | 154,445 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In the army, it isn't easy to form a group of soldiers that will be effective on the battlefield. The communication is crucial and thus no two soldiers should share a name (what would happen if they got an order that Bob is a scouter, if there are two Bobs?).
A group of soldiers is effective if and only if their names are different. For example, a group (John, Bob, Limak) would be effective, while groups (Gary, Bob, Gary) and (Alice, Alice) wouldn't.
You are a spy in the enemy's camp. You noticed n soldiers standing in a row, numbered 1 through n. The general wants to choose a group of k consecutive soldiers. For every k consecutive soldiers, the general wrote down whether they would be an effective group or not.
You managed to steal the general's notes, with n - k + 1 strings s1, s2, ..., sn - k + 1, each either "YES" or "NO".
* The string s1 describes a group of soldiers 1 through k ("YES" if the group is effective, and "NO" otherwise).
* The string s2 describes a group of soldiers 2 through k + 1.
* And so on, till the string sn - k + 1 that describes a group of soldiers n - k + 1 through n.
Your task is to find possible names of n soldiers. Names should match the stolen notes. Each name should be a string that consists of between 1 and 10 English letters, inclusive. The first letter should be uppercase, and all other letters should be lowercase. Names don't have to be existing names — it's allowed to print "Xyzzzdj" or "T" for example.
Find and print any solution. It can be proved that there always exists at least one solution.
Input
The first line of the input contains two integers n and k (2 ≤ k ≤ n ≤ 50) — the number of soldiers and the size of a group respectively.
The second line contains n - k + 1 strings s1, s2, ..., sn - k + 1. The string si is "YES" if the group of soldiers i through i + k - 1 is effective, and "NO" otherwise.
Output
Find any solution satisfying all given conditions. In one line print n space-separated strings, denoting possible names of soldiers in the order. The first letter of each name should be uppercase, while the other letters should be lowercase. Each name should contain English letters only and has length from 1 to 10.
If there are multiple valid solutions, print any of them.
Examples
Input
8 3
NO NO YES YES YES NO
Output
Adam Bob Bob Cpqepqwer Limak Adam Bob Adam
Input
9 8
YES NO
Output
R Q Ccccccccc Ccocc Ccc So Strong Samples Ccc
Input
3 2
NO NO
Output
Na Na Na
Note
In the first sample, there are 8 soldiers. For every 3 consecutive ones we know whether they would be an effective group. Let's analyze the provided sample output:
* First three soldiers (i.e. Adam, Bob, Bob) wouldn't be an effective group because there are two Bobs. Indeed, the string s1 is "NO".
* Soldiers 2 through 4 (Bob, Bob, Cpqepqwer) wouldn't be effective either, and the string s2 is "NO".
* Soldiers 3 through 5 (Bob, Cpqepqwer, Limak) would be effective, and the string s3 is "YES".
* ...,
* Soldiers 6 through 8 (Adam, Bob, Adam) wouldn't be effective, and the string s6 is "NO". | instruction | 0 | 77,223 | 14 | 154,446 |
Tags: constructive algorithms, greedy
Correct Solution:
```
from string import ascii_uppercase
n,k=map(int,input().split())
s=list(input().split())
#print(len(s))
names=[]
for i in ascii_uppercase:
names.append(i)
names.append('A'+str(i).lower())
#print(names)
a=[]
if s[0]=='YES':
for i in range(k):
a.append(names[i])
elif s[0]=='NO':
for i in range(k-1):
a.append(names[i])
a.append(names[0])
for j in range(1,len(s)):
#print(j)
if s[j]=='YES':
a.append(names[k-1+j])
else:
a.append(a[j])
print(*a)
``` | output | 1 | 77,223 | 14 | 154,447 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In the army, it isn't easy to form a group of soldiers that will be effective on the battlefield. The communication is crucial and thus no two soldiers should share a name (what would happen if they got an order that Bob is a scouter, if there are two Bobs?).
A group of soldiers is effective if and only if their names are different. For example, a group (John, Bob, Limak) would be effective, while groups (Gary, Bob, Gary) and (Alice, Alice) wouldn't.
You are a spy in the enemy's camp. You noticed n soldiers standing in a row, numbered 1 through n. The general wants to choose a group of k consecutive soldiers. For every k consecutive soldiers, the general wrote down whether they would be an effective group or not.
You managed to steal the general's notes, with n - k + 1 strings s1, s2, ..., sn - k + 1, each either "YES" or "NO".
* The string s1 describes a group of soldiers 1 through k ("YES" if the group is effective, and "NO" otherwise).
* The string s2 describes a group of soldiers 2 through k + 1.
* And so on, till the string sn - k + 1 that describes a group of soldiers n - k + 1 through n.
Your task is to find possible names of n soldiers. Names should match the stolen notes. Each name should be a string that consists of between 1 and 10 English letters, inclusive. The first letter should be uppercase, and all other letters should be lowercase. Names don't have to be existing names — it's allowed to print "Xyzzzdj" or "T" for example.
Find and print any solution. It can be proved that there always exists at least one solution.
Input
The first line of the input contains two integers n and k (2 ≤ k ≤ n ≤ 50) — the number of soldiers and the size of a group respectively.
The second line contains n - k + 1 strings s1, s2, ..., sn - k + 1. The string si is "YES" if the group of soldiers i through i + k - 1 is effective, and "NO" otherwise.
Output
Find any solution satisfying all given conditions. In one line print n space-separated strings, denoting possible names of soldiers in the order. The first letter of each name should be uppercase, while the other letters should be lowercase. Each name should contain English letters only and has length from 1 to 10.
If there are multiple valid solutions, print any of them.
Examples
Input
8 3
NO NO YES YES YES NO
Output
Adam Bob Bob Cpqepqwer Limak Adam Bob Adam
Input
9 8
YES NO
Output
R Q Ccccccccc Ccocc Ccc So Strong Samples Ccc
Input
3 2
NO NO
Output
Na Na Na
Note
In the first sample, there are 8 soldiers. For every 3 consecutive ones we know whether they would be an effective group. Let's analyze the provided sample output:
* First three soldiers (i.e. Adam, Bob, Bob) wouldn't be an effective group because there are two Bobs. Indeed, the string s1 is "NO".
* Soldiers 2 through 4 (Bob, Bob, Cpqepqwer) wouldn't be effective either, and the string s2 is "NO".
* Soldiers 3 through 5 (Bob, Cpqepqwer, Limak) would be effective, and the string s3 is "YES".
* ...,
* Soldiers 6 through 8 (Adam, Bob, Adam) wouldn't be effective, and the string s6 is "NO". | instruction | 0 | 77,224 | 14 | 154,448 |
Tags: constructive algorithms, greedy
Correct Solution:
```
R= lambda: map(int,input().split())
n,k =R()
l=[]
s,s2= ord('A'),ord('a')
for i in range(k):
if i<26:
l.append(chr(s+i))
else: l.append('A'+chr(s2+(i%26)))
if i<k-1: print(l[i],end=' ')
s=[i for i in range(k-1)]
i,j=k-1,0
c=input().split()
for m in range(n-k+1):
if c[m]=='YES':
print(l[i],end=' ')
s.append(i)
i=s[j]
else:
print(l[s[j]],end=' ')
s.append(s[j])
j=j+1
``` | output | 1 | 77,224 | 14 | 154,449 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In the army, it isn't easy to form a group of soldiers that will be effective on the battlefield. The communication is crucial and thus no two soldiers should share a name (what would happen if they got an order that Bob is a scouter, if there are two Bobs?).
A group of soldiers is effective if and only if their names are different. For example, a group (John, Bob, Limak) would be effective, while groups (Gary, Bob, Gary) and (Alice, Alice) wouldn't.
You are a spy in the enemy's camp. You noticed n soldiers standing in a row, numbered 1 through n. The general wants to choose a group of k consecutive soldiers. For every k consecutive soldiers, the general wrote down whether they would be an effective group or not.
You managed to steal the general's notes, with n - k + 1 strings s1, s2, ..., sn - k + 1, each either "YES" or "NO".
* The string s1 describes a group of soldiers 1 through k ("YES" if the group is effective, and "NO" otherwise).
* The string s2 describes a group of soldiers 2 through k + 1.
* And so on, till the string sn - k + 1 that describes a group of soldiers n - k + 1 through n.
Your task is to find possible names of n soldiers. Names should match the stolen notes. Each name should be a string that consists of between 1 and 10 English letters, inclusive. The first letter should be uppercase, and all other letters should be lowercase. Names don't have to be existing names — it's allowed to print "Xyzzzdj" or "T" for example.
Find and print any solution. It can be proved that there always exists at least one solution.
Input
The first line of the input contains two integers n and k (2 ≤ k ≤ n ≤ 50) — the number of soldiers and the size of a group respectively.
The second line contains n - k + 1 strings s1, s2, ..., sn - k + 1. The string si is "YES" if the group of soldiers i through i + k - 1 is effective, and "NO" otherwise.
Output
Find any solution satisfying all given conditions. In one line print n space-separated strings, denoting possible names of soldiers in the order. The first letter of each name should be uppercase, while the other letters should be lowercase. Each name should contain English letters only and has length from 1 to 10.
If there are multiple valid solutions, print any of them.
Examples
Input
8 3
NO NO YES YES YES NO
Output
Adam Bob Bob Cpqepqwer Limak Adam Bob Adam
Input
9 8
YES NO
Output
R Q Ccccccccc Ccocc Ccc So Strong Samples Ccc
Input
3 2
NO NO
Output
Na Na Na
Note
In the first sample, there are 8 soldiers. For every 3 consecutive ones we know whether they would be an effective group. Let's analyze the provided sample output:
* First three soldiers (i.e. Adam, Bob, Bob) wouldn't be an effective group because there are two Bobs. Indeed, the string s1 is "NO".
* Soldiers 2 through 4 (Bob, Bob, Cpqepqwer) wouldn't be effective either, and the string s2 is "NO".
* Soldiers 3 through 5 (Bob, Cpqepqwer, Limak) would be effective, and the string s3 is "YES".
* ...,
* Soldiers 6 through 8 (Adam, Bob, Adam) wouldn't be effective, and the string s6 is "NO". | instruction | 0 | 77,225 | 14 | 154,450 |
Tags: constructive algorithms, greedy
Correct Solution:
```
n, k = map(int, input().split())
names = []
for i in range(ord('a'), ord('z') + 1):
names.append('A' + chr(i))
for i in range(ord('a'), ord('z') + 1):
names.append('B' + chr(i))
pos = 0
a = input().split()
ans = []
for i in range(k - 1):
ans.append(names[pos])
pos += 1
for i in range(n - k + 1):
if a[i] == "YES":
ans.append(names[pos])
pos += 1
else:
ans.append(ans[i])
print(' '.join(ans))
``` | output | 1 | 77,225 | 14 | 154,451 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In the army, it isn't easy to form a group of soldiers that will be effective on the battlefield. The communication is crucial and thus no two soldiers should share a name (what would happen if they got an order that Bob is a scouter, if there are two Bobs?).
A group of soldiers is effective if and only if their names are different. For example, a group (John, Bob, Limak) would be effective, while groups (Gary, Bob, Gary) and (Alice, Alice) wouldn't.
You are a spy in the enemy's camp. You noticed n soldiers standing in a row, numbered 1 through n. The general wants to choose a group of k consecutive soldiers. For every k consecutive soldiers, the general wrote down whether they would be an effective group or not.
You managed to steal the general's notes, with n - k + 1 strings s1, s2, ..., sn - k + 1, each either "YES" or "NO".
* The string s1 describes a group of soldiers 1 through k ("YES" if the group is effective, and "NO" otherwise).
* The string s2 describes a group of soldiers 2 through k + 1.
* And so on, till the string sn - k + 1 that describes a group of soldiers n - k + 1 through n.
Your task is to find possible names of n soldiers. Names should match the stolen notes. Each name should be a string that consists of between 1 and 10 English letters, inclusive. The first letter should be uppercase, and all other letters should be lowercase. Names don't have to be existing names — it's allowed to print "Xyzzzdj" or "T" for example.
Find and print any solution. It can be proved that there always exists at least one solution.
Input
The first line of the input contains two integers n and k (2 ≤ k ≤ n ≤ 50) — the number of soldiers and the size of a group respectively.
The second line contains n - k + 1 strings s1, s2, ..., sn - k + 1. The string si is "YES" if the group of soldiers i through i + k - 1 is effective, and "NO" otherwise.
Output
Find any solution satisfying all given conditions. In one line print n space-separated strings, denoting possible names of soldiers in the order. The first letter of each name should be uppercase, while the other letters should be lowercase. Each name should contain English letters only and has length from 1 to 10.
If there are multiple valid solutions, print any of them.
Examples
Input
8 3
NO NO YES YES YES NO
Output
Adam Bob Bob Cpqepqwer Limak Adam Bob Adam
Input
9 8
YES NO
Output
R Q Ccccccccc Ccocc Ccc So Strong Samples Ccc
Input
3 2
NO NO
Output
Na Na Na
Note
In the first sample, there are 8 soldiers. For every 3 consecutive ones we know whether they would be an effective group. Let's analyze the provided sample output:
* First three soldiers (i.e. Adam, Bob, Bob) wouldn't be an effective group because there are two Bobs. Indeed, the string s1 is "NO".
* Soldiers 2 through 4 (Bob, Bob, Cpqepqwer) wouldn't be effective either, and the string s2 is "NO".
* Soldiers 3 through 5 (Bob, Cpqepqwer, Limak) would be effective, and the string s3 is "YES".
* ...,
* Soldiers 6 through 8 (Adam, Bob, Adam) wouldn't be effective, and the string s6 is "NO". | instruction | 0 | 77,226 | 14 | 154,452 |
Tags: constructive algorithms, greedy
Correct Solution:
```
def name(n):
return chr(ord('A') + n % 26) + chr(ord('a') + n // 26)
def main():
n, k = map(int, input().split())
arr = list(map(str, input().split()))
if (arr.count("YES") == 0):
for i in range(n):
print("Max ", end = "")
return
ans = ["" for i in range(n)]
x = arr.index("YES")
for i in range(k):
ans[x + i] = name(i + x)
for i in range(x + 1, n - k + 1):
if (arr[i] == "YES"):
ans[i + k - 1] = name(i + k - 1)
else:
ans[i + k - 1] = ans[i]
for i in range(x - 1, -1, -1):
if (arr[i] == "YES"):
ans[i] = name(i)
else:
ans[i] = ans[i + k - 1]
print(*ans)
main()
``` | output | 1 | 77,226 | 14 | 154,453 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In the army, it isn't easy to form a group of soldiers that will be effective on the battlefield. The communication is crucial and thus no two soldiers should share a name (what would happen if they got an order that Bob is a scouter, if there are two Bobs?).
A group of soldiers is effective if and only if their names are different. For example, a group (John, Bob, Limak) would be effective, while groups (Gary, Bob, Gary) and (Alice, Alice) wouldn't.
You are a spy in the enemy's camp. You noticed n soldiers standing in a row, numbered 1 through n. The general wants to choose a group of k consecutive soldiers. For every k consecutive soldiers, the general wrote down whether they would be an effective group or not.
You managed to steal the general's notes, with n - k + 1 strings s1, s2, ..., sn - k + 1, each either "YES" or "NO".
* The string s1 describes a group of soldiers 1 through k ("YES" if the group is effective, and "NO" otherwise).
* The string s2 describes a group of soldiers 2 through k + 1.
* And so on, till the string sn - k + 1 that describes a group of soldiers n - k + 1 through n.
Your task is to find possible names of n soldiers. Names should match the stolen notes. Each name should be a string that consists of between 1 and 10 English letters, inclusive. The first letter should be uppercase, and all other letters should be lowercase. Names don't have to be existing names — it's allowed to print "Xyzzzdj" or "T" for example.
Find and print any solution. It can be proved that there always exists at least one solution.
Input
The first line of the input contains two integers n and k (2 ≤ k ≤ n ≤ 50) — the number of soldiers and the size of a group respectively.
The second line contains n - k + 1 strings s1, s2, ..., sn - k + 1. The string si is "YES" if the group of soldiers i through i + k - 1 is effective, and "NO" otherwise.
Output
Find any solution satisfying all given conditions. In one line print n space-separated strings, denoting possible names of soldiers in the order. The first letter of each name should be uppercase, while the other letters should be lowercase. Each name should contain English letters only and has length from 1 to 10.
If there are multiple valid solutions, print any of them.
Examples
Input
8 3
NO NO YES YES YES NO
Output
Adam Bob Bob Cpqepqwer Limak Adam Bob Adam
Input
9 8
YES NO
Output
R Q Ccccccccc Ccocc Ccc So Strong Samples Ccc
Input
3 2
NO NO
Output
Na Na Na
Note
In the first sample, there are 8 soldiers. For every 3 consecutive ones we know whether they would be an effective group. Let's analyze the provided sample output:
* First three soldiers (i.e. Adam, Bob, Bob) wouldn't be an effective group because there are two Bobs. Indeed, the string s1 is "NO".
* Soldiers 2 through 4 (Bob, Bob, Cpqepqwer) wouldn't be effective either, and the string s2 is "NO".
* Soldiers 3 through 5 (Bob, Cpqepqwer, Limak) would be effective, and the string s3 is "YES".
* ...,
* Soldiers 6 through 8 (Adam, Bob, Adam) wouldn't be effective, and the string s6 is "NO". | instruction | 0 | 77,227 | 14 | 154,454 |
Tags: constructive algorithms, greedy
Correct Solution:
```
n, k = map(int, input().split()) ##n - k + 1 - всего запросов
names = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'Aa', 'Bb', 'Cc', 'Dd', 'Ee', 'Ff', 'Gg', 'Hh', 'Ii', 'Jj', 'Kk', 'Ll', 'Mm', 'Nn', 'Oo', 'Pp', 'Qq', 'Rr', 'Ss', 'Tt', 'Uu', 'Vv', 'Ww', 'Xx', 'Yy', 'Zz']
e = input().split()
names = names[:n]
for i in range(n - k + 1):
if e[i] == 'NO':
names[i + k - 1] = names[i]
ans = (' ').join(names)
print(ans)
``` | output | 1 | 77,227 | 14 | 154,455 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In the army, it isn't easy to form a group of soldiers that will be effective on the battlefield. The communication is crucial and thus no two soldiers should share a name (what would happen if they got an order that Bob is a scouter, if there are two Bobs?).
A group of soldiers is effective if and only if their names are different. For example, a group (John, Bob, Limak) would be effective, while groups (Gary, Bob, Gary) and (Alice, Alice) wouldn't.
You are a spy in the enemy's camp. You noticed n soldiers standing in a row, numbered 1 through n. The general wants to choose a group of k consecutive soldiers. For every k consecutive soldiers, the general wrote down whether they would be an effective group or not.
You managed to steal the general's notes, with n - k + 1 strings s1, s2, ..., sn - k + 1, each either "YES" or "NO".
* The string s1 describes a group of soldiers 1 through k ("YES" if the group is effective, and "NO" otherwise).
* The string s2 describes a group of soldiers 2 through k + 1.
* And so on, till the string sn - k + 1 that describes a group of soldiers n - k + 1 through n.
Your task is to find possible names of n soldiers. Names should match the stolen notes. Each name should be a string that consists of between 1 and 10 English letters, inclusive. The first letter should be uppercase, and all other letters should be lowercase. Names don't have to be existing names — it's allowed to print "Xyzzzdj" or "T" for example.
Find and print any solution. It can be proved that there always exists at least one solution.
Input
The first line of the input contains two integers n and k (2 ≤ k ≤ n ≤ 50) — the number of soldiers and the size of a group respectively.
The second line contains n - k + 1 strings s1, s2, ..., sn - k + 1. The string si is "YES" if the group of soldiers i through i + k - 1 is effective, and "NO" otherwise.
Output
Find any solution satisfying all given conditions. In one line print n space-separated strings, denoting possible names of soldiers in the order. The first letter of each name should be uppercase, while the other letters should be lowercase. Each name should contain English letters only and has length from 1 to 10.
If there are multiple valid solutions, print any of them.
Examples
Input
8 3
NO NO YES YES YES NO
Output
Adam Bob Bob Cpqepqwer Limak Adam Bob Adam
Input
9 8
YES NO
Output
R Q Ccccccccc Ccocc Ccc So Strong Samples Ccc
Input
3 2
NO NO
Output
Na Na Na
Note
In the first sample, there are 8 soldiers. For every 3 consecutive ones we know whether they would be an effective group. Let's analyze the provided sample output:
* First three soldiers (i.e. Adam, Bob, Bob) wouldn't be an effective group because there are two Bobs. Indeed, the string s1 is "NO".
* Soldiers 2 through 4 (Bob, Bob, Cpqepqwer) wouldn't be effective either, and the string s2 is "NO".
* Soldiers 3 through 5 (Bob, Cpqepqwer, Limak) would be effective, and the string s3 is "YES".
* ...,
* Soldiers 6 through 8 (Adam, Bob, Adam) wouldn't be effective, and the string s6 is "NO". | instruction | 0 | 77,228 | 14 | 154,456 |
Tags: constructive algorithms, greedy
Correct Solution:
```
n,k=map(int,input().split())
l=list(map(str,input().split()))
A=['A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','Aa','Ab','Ac','Ad','Ae','Af','Ag','Ah','Ai','Aj','Ak','Al','Am','An','Ao','Ap','Aq','Ar','As','At','Au','Av','Aw','Ax','Ay','Az']
ans=[]
for i in range(k-1):
ans.append(A[i])
temp1=0
temp2=k-1
for i in range(len(l)):
if l[i]=="YES":
ans.append(A[temp2])
temp2+=1
else:
ans.append(ans[-k+1])
print(*ans)
``` | output | 1 | 77,228 | 14 | 154,457 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the army, it isn't easy to form a group of soldiers that will be effective on the battlefield. The communication is crucial and thus no two soldiers should share a name (what would happen if they got an order that Bob is a scouter, if there are two Bobs?).
A group of soldiers is effective if and only if their names are different. For example, a group (John, Bob, Limak) would be effective, while groups (Gary, Bob, Gary) and (Alice, Alice) wouldn't.
You are a spy in the enemy's camp. You noticed n soldiers standing in a row, numbered 1 through n. The general wants to choose a group of k consecutive soldiers. For every k consecutive soldiers, the general wrote down whether they would be an effective group or not.
You managed to steal the general's notes, with n - k + 1 strings s1, s2, ..., sn - k + 1, each either "YES" or "NO".
* The string s1 describes a group of soldiers 1 through k ("YES" if the group is effective, and "NO" otherwise).
* The string s2 describes a group of soldiers 2 through k + 1.
* And so on, till the string sn - k + 1 that describes a group of soldiers n - k + 1 through n.
Your task is to find possible names of n soldiers. Names should match the stolen notes. Each name should be a string that consists of between 1 and 10 English letters, inclusive. The first letter should be uppercase, and all other letters should be lowercase. Names don't have to be existing names — it's allowed to print "Xyzzzdj" or "T" for example.
Find and print any solution. It can be proved that there always exists at least one solution.
Input
The first line of the input contains two integers n and k (2 ≤ k ≤ n ≤ 50) — the number of soldiers and the size of a group respectively.
The second line contains n - k + 1 strings s1, s2, ..., sn - k + 1. The string si is "YES" if the group of soldiers i through i + k - 1 is effective, and "NO" otherwise.
Output
Find any solution satisfying all given conditions. In one line print n space-separated strings, denoting possible names of soldiers in the order. The first letter of each name should be uppercase, while the other letters should be lowercase. Each name should contain English letters only and has length from 1 to 10.
If there are multiple valid solutions, print any of them.
Examples
Input
8 3
NO NO YES YES YES NO
Output
Adam Bob Bob Cpqepqwer Limak Adam Bob Adam
Input
9 8
YES NO
Output
R Q Ccccccccc Ccocc Ccc So Strong Samples Ccc
Input
3 2
NO NO
Output
Na Na Na
Note
In the first sample, there are 8 soldiers. For every 3 consecutive ones we know whether they would be an effective group. Let's analyze the provided sample output:
* First three soldiers (i.e. Adam, Bob, Bob) wouldn't be an effective group because there are two Bobs. Indeed, the string s1 is "NO".
* Soldiers 2 through 4 (Bob, Bob, Cpqepqwer) wouldn't be effective either, and the string s2 is "NO".
* Soldiers 3 through 5 (Bob, Cpqepqwer, Limak) would be effective, and the string s3 is "YES".
* ...,
* Soldiers 6 through 8 (Adam, Bob, Adam) wouldn't be effective, and the string s6 is "NO".
Submitted Solution:
```
n, k = map(int, input().split())
l = [True if x == 'YES' else False for x in input().split()]
res = list(range(k - 1))
for i in l:
if i:
for j in range(k):
if j not in res[-k+1:]:
res.append(j)
break
else:
res.append(res[-k + 1])
names = [chr(x) + chr(y) for x in range(ord('A'), ord('Z') + 1) for y in range(ord('a'), ord('z') + 1)]
for i in res:
print(names[i], end=' ')
print()
``` | instruction | 0 | 77,229 | 14 | 154,458 |
Yes | output | 1 | 77,229 | 14 | 154,459 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the army, it isn't easy to form a group of soldiers that will be effective on the battlefield. The communication is crucial and thus no two soldiers should share a name (what would happen if they got an order that Bob is a scouter, if there are two Bobs?).
A group of soldiers is effective if and only if their names are different. For example, a group (John, Bob, Limak) would be effective, while groups (Gary, Bob, Gary) and (Alice, Alice) wouldn't.
You are a spy in the enemy's camp. You noticed n soldiers standing in a row, numbered 1 through n. The general wants to choose a group of k consecutive soldiers. For every k consecutive soldiers, the general wrote down whether they would be an effective group or not.
You managed to steal the general's notes, with n - k + 1 strings s1, s2, ..., sn - k + 1, each either "YES" or "NO".
* The string s1 describes a group of soldiers 1 through k ("YES" if the group is effective, and "NO" otherwise).
* The string s2 describes a group of soldiers 2 through k + 1.
* And so on, till the string sn - k + 1 that describes a group of soldiers n - k + 1 through n.
Your task is to find possible names of n soldiers. Names should match the stolen notes. Each name should be a string that consists of between 1 and 10 English letters, inclusive. The first letter should be uppercase, and all other letters should be lowercase. Names don't have to be existing names — it's allowed to print "Xyzzzdj" or "T" for example.
Find and print any solution. It can be proved that there always exists at least one solution.
Input
The first line of the input contains two integers n and k (2 ≤ k ≤ n ≤ 50) — the number of soldiers and the size of a group respectively.
The second line contains n - k + 1 strings s1, s2, ..., sn - k + 1. The string si is "YES" if the group of soldiers i through i + k - 1 is effective, and "NO" otherwise.
Output
Find any solution satisfying all given conditions. In one line print n space-separated strings, denoting possible names of soldiers in the order. The first letter of each name should be uppercase, while the other letters should be lowercase. Each name should contain English letters only and has length from 1 to 10.
If there are multiple valid solutions, print any of them.
Examples
Input
8 3
NO NO YES YES YES NO
Output
Adam Bob Bob Cpqepqwer Limak Adam Bob Adam
Input
9 8
YES NO
Output
R Q Ccccccccc Ccocc Ccc So Strong Samples Ccc
Input
3 2
NO NO
Output
Na Na Na
Note
In the first sample, there are 8 soldiers. For every 3 consecutive ones we know whether they would be an effective group. Let's analyze the provided sample output:
* First three soldiers (i.e. Adam, Bob, Bob) wouldn't be an effective group because there are two Bobs. Indeed, the string s1 is "NO".
* Soldiers 2 through 4 (Bob, Bob, Cpqepqwer) wouldn't be effective either, and the string s2 is "NO".
* Soldiers 3 through 5 (Bob, Cpqepqwer, Limak) would be effective, and the string s3 is "YES".
* ...,
* Soldiers 6 through 8 (Adam, Bob, Adam) wouldn't be effective, and the string s6 is "NO".
Submitted Solution:
```
names = [chr(ord('A') + i) for i in range(26)]
names += ['A' + chr(ord('a') + i) for i in range(26)]
n, k = map(int, input().split())
a = input().split()
for i, a_i in enumerate(a):
if a_i == 'NO':
names[i+k-1] = names[i]
print(' '.join(names[:n]))
``` | instruction | 0 | 77,230 | 14 | 154,460 |
Yes | output | 1 | 77,230 | 14 | 154,461 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the army, it isn't easy to form a group of soldiers that will be effective on the battlefield. The communication is crucial and thus no two soldiers should share a name (what would happen if they got an order that Bob is a scouter, if there are two Bobs?).
A group of soldiers is effective if and only if their names are different. For example, a group (John, Bob, Limak) would be effective, while groups (Gary, Bob, Gary) and (Alice, Alice) wouldn't.
You are a spy in the enemy's camp. You noticed n soldiers standing in a row, numbered 1 through n. The general wants to choose a group of k consecutive soldiers. For every k consecutive soldiers, the general wrote down whether they would be an effective group or not.
You managed to steal the general's notes, with n - k + 1 strings s1, s2, ..., sn - k + 1, each either "YES" or "NO".
* The string s1 describes a group of soldiers 1 through k ("YES" if the group is effective, and "NO" otherwise).
* The string s2 describes a group of soldiers 2 through k + 1.
* And so on, till the string sn - k + 1 that describes a group of soldiers n - k + 1 through n.
Your task is to find possible names of n soldiers. Names should match the stolen notes. Each name should be a string that consists of between 1 and 10 English letters, inclusive. The first letter should be uppercase, and all other letters should be lowercase. Names don't have to be existing names — it's allowed to print "Xyzzzdj" or "T" for example.
Find and print any solution. It can be proved that there always exists at least one solution.
Input
The first line of the input contains two integers n and k (2 ≤ k ≤ n ≤ 50) — the number of soldiers and the size of a group respectively.
The second line contains n - k + 1 strings s1, s2, ..., sn - k + 1. The string si is "YES" if the group of soldiers i through i + k - 1 is effective, and "NO" otherwise.
Output
Find any solution satisfying all given conditions. In one line print n space-separated strings, denoting possible names of soldiers in the order. The first letter of each name should be uppercase, while the other letters should be lowercase. Each name should contain English letters only and has length from 1 to 10.
If there are multiple valid solutions, print any of them.
Examples
Input
8 3
NO NO YES YES YES NO
Output
Adam Bob Bob Cpqepqwer Limak Adam Bob Adam
Input
9 8
YES NO
Output
R Q Ccccccccc Ccocc Ccc So Strong Samples Ccc
Input
3 2
NO NO
Output
Na Na Na
Note
In the first sample, there are 8 soldiers. For every 3 consecutive ones we know whether they would be an effective group. Let's analyze the provided sample output:
* First three soldiers (i.e. Adam, Bob, Bob) wouldn't be an effective group because there are two Bobs. Indeed, the string s1 is "NO".
* Soldiers 2 through 4 (Bob, Bob, Cpqepqwer) wouldn't be effective either, and the string s2 is "NO".
* Soldiers 3 through 5 (Bob, Cpqepqwer, Limak) would be effective, and the string s3 is "YES".
* ...,
* Soldiers 6 through 8 (Adam, Bob, Adam) wouldn't be effective, and the string s6 is "NO".
Submitted Solution:
```
from string import ascii_lowercase
import collections
n, m = map(int, input().split())
l = list(input().split())
answer = collections.deque()
Names= []
start, end =0,m-1
for i in ascii_lowercase.upper():
for j in ascii_lowercase:
Names.append(i+j)
for i in range(0, m-1):
print(Names[i], end=" ")
answer.append(Names[i])
for i in l:
if i =="YES":
answer.append(Names[end])
end+=1
else:
answer.append(answer[0])
answer.popleft()
print(answer[-1], end=" ")
``` | instruction | 0 | 77,231 | 14 | 154,462 |
Yes | output | 1 | 77,231 | 14 | 154,463 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the army, it isn't easy to form a group of soldiers that will be effective on the battlefield. The communication is crucial and thus no two soldiers should share a name (what would happen if they got an order that Bob is a scouter, if there are two Bobs?).
A group of soldiers is effective if and only if their names are different. For example, a group (John, Bob, Limak) would be effective, while groups (Gary, Bob, Gary) and (Alice, Alice) wouldn't.
You are a spy in the enemy's camp. You noticed n soldiers standing in a row, numbered 1 through n. The general wants to choose a group of k consecutive soldiers. For every k consecutive soldiers, the general wrote down whether they would be an effective group or not.
You managed to steal the general's notes, with n - k + 1 strings s1, s2, ..., sn - k + 1, each either "YES" or "NO".
* The string s1 describes a group of soldiers 1 through k ("YES" if the group is effective, and "NO" otherwise).
* The string s2 describes a group of soldiers 2 through k + 1.
* And so on, till the string sn - k + 1 that describes a group of soldiers n - k + 1 through n.
Your task is to find possible names of n soldiers. Names should match the stolen notes. Each name should be a string that consists of between 1 and 10 English letters, inclusive. The first letter should be uppercase, and all other letters should be lowercase. Names don't have to be existing names — it's allowed to print "Xyzzzdj" or "T" for example.
Find and print any solution. It can be proved that there always exists at least one solution.
Input
The first line of the input contains two integers n and k (2 ≤ k ≤ n ≤ 50) — the number of soldiers and the size of a group respectively.
The second line contains n - k + 1 strings s1, s2, ..., sn - k + 1. The string si is "YES" if the group of soldiers i through i + k - 1 is effective, and "NO" otherwise.
Output
Find any solution satisfying all given conditions. In one line print n space-separated strings, denoting possible names of soldiers in the order. The first letter of each name should be uppercase, while the other letters should be lowercase. Each name should contain English letters only and has length from 1 to 10.
If there are multiple valid solutions, print any of them.
Examples
Input
8 3
NO NO YES YES YES NO
Output
Adam Bob Bob Cpqepqwer Limak Adam Bob Adam
Input
9 8
YES NO
Output
R Q Ccccccccc Ccocc Ccc So Strong Samples Ccc
Input
3 2
NO NO
Output
Na Na Na
Note
In the first sample, there are 8 soldiers. For every 3 consecutive ones we know whether they would be an effective group. Let's analyze the provided sample output:
* First three soldiers (i.e. Adam, Bob, Bob) wouldn't be an effective group because there are two Bobs. Indeed, the string s1 is "NO".
* Soldiers 2 through 4 (Bob, Bob, Cpqepqwer) wouldn't be effective either, and the string s2 is "NO".
* Soldiers 3 through 5 (Bob, Cpqepqwer, Limak) would be effective, and the string s3 is "YES".
* ...,
* Soldiers 6 through 8 (Adam, Bob, Adam) wouldn't be effective, and the string s6 is "NO".
Submitted Solution:
```
l=['Aa','Ab','Ac','Ad','Ae','Af','Ag','Ah','Ai','Aj','Ak','Al','Am','An','Ao','Ap','Aq','Ar','As','At','Au','Av','Aw','Ax','Ay','Az','Aaa','Abb','Acc','Add','Aee','Aff','Agg','Ahh','Aii','Ajj','Akk','All','Amm','Ann','Aoo','App','Aqq','Arr','Ass','Att','Auu','Avv','Aww','Axx','Ayy']
n,k=map(int,input().split())
li=list(map(str,input().split()))
lc=l[:n]
for i in range(len(li)):
if li[i]=="NO":
lc[i+k-1]=lc[i]
for i in lc:
print(i,end=" ")
``` | instruction | 0 | 77,232 | 14 | 154,464 |
Yes | output | 1 | 77,232 | 14 | 154,465 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the army, it isn't easy to form a group of soldiers that will be effective on the battlefield. The communication is crucial and thus no two soldiers should share a name (what would happen if they got an order that Bob is a scouter, if there are two Bobs?).
A group of soldiers is effective if and only if their names are different. For example, a group (John, Bob, Limak) would be effective, while groups (Gary, Bob, Gary) and (Alice, Alice) wouldn't.
You are a spy in the enemy's camp. You noticed n soldiers standing in a row, numbered 1 through n. The general wants to choose a group of k consecutive soldiers. For every k consecutive soldiers, the general wrote down whether they would be an effective group or not.
You managed to steal the general's notes, with n - k + 1 strings s1, s2, ..., sn - k + 1, each either "YES" or "NO".
* The string s1 describes a group of soldiers 1 through k ("YES" if the group is effective, and "NO" otherwise).
* The string s2 describes a group of soldiers 2 through k + 1.
* And so on, till the string sn - k + 1 that describes a group of soldiers n - k + 1 through n.
Your task is to find possible names of n soldiers. Names should match the stolen notes. Each name should be a string that consists of between 1 and 10 English letters, inclusive. The first letter should be uppercase, and all other letters should be lowercase. Names don't have to be existing names — it's allowed to print "Xyzzzdj" or "T" for example.
Find and print any solution. It can be proved that there always exists at least one solution.
Input
The first line of the input contains two integers n and k (2 ≤ k ≤ n ≤ 50) — the number of soldiers and the size of a group respectively.
The second line contains n - k + 1 strings s1, s2, ..., sn - k + 1. The string si is "YES" if the group of soldiers i through i + k - 1 is effective, and "NO" otherwise.
Output
Find any solution satisfying all given conditions. In one line print n space-separated strings, denoting possible names of soldiers in the order. The first letter of each name should be uppercase, while the other letters should be lowercase. Each name should contain English letters only and has length from 1 to 10.
If there are multiple valid solutions, print any of them.
Examples
Input
8 3
NO NO YES YES YES NO
Output
Adam Bob Bob Cpqepqwer Limak Adam Bob Adam
Input
9 8
YES NO
Output
R Q Ccccccccc Ccocc Ccc So Strong Samples Ccc
Input
3 2
NO NO
Output
Na Na Na
Note
In the first sample, there are 8 soldiers. For every 3 consecutive ones we know whether they would be an effective group. Let's analyze the provided sample output:
* First three soldiers (i.e. Adam, Bob, Bob) wouldn't be an effective group because there are two Bobs. Indeed, the string s1 is "NO".
* Soldiers 2 through 4 (Bob, Bob, Cpqepqwer) wouldn't be effective either, and the string s2 is "NO".
* Soldiers 3 through 5 (Bob, Cpqepqwer, Limak) would be effective, and the string s3 is "YES".
* ...,
* Soldiers 6 through 8 (Adam, Bob, Adam) wouldn't be effective, and the string s6 is "NO".
Submitted Solution:
```
n,k = map(int,input().split())
answers = input().split()
names = []
army = []
for i in range(26):
names.append('Aa'+chr(ord('a')+i))
for i in range(24):
names.append('Ab'+chr(ord('a')+i))
for i in range(n-k+1):
if answers[i] == 'No':
names[i+k] = names[i]
print(names)
``` | instruction | 0 | 77,233 | 14 | 154,466 |
No | output | 1 | 77,233 | 14 | 154,467 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the army, it isn't easy to form a group of soldiers that will be effective on the battlefield. The communication is crucial and thus no two soldiers should share a name (what would happen if they got an order that Bob is a scouter, if there are two Bobs?).
A group of soldiers is effective if and only if their names are different. For example, a group (John, Bob, Limak) would be effective, while groups (Gary, Bob, Gary) and (Alice, Alice) wouldn't.
You are a spy in the enemy's camp. You noticed n soldiers standing in a row, numbered 1 through n. The general wants to choose a group of k consecutive soldiers. For every k consecutive soldiers, the general wrote down whether they would be an effective group or not.
You managed to steal the general's notes, with n - k + 1 strings s1, s2, ..., sn - k + 1, each either "YES" or "NO".
* The string s1 describes a group of soldiers 1 through k ("YES" if the group is effective, and "NO" otherwise).
* The string s2 describes a group of soldiers 2 through k + 1.
* And so on, till the string sn - k + 1 that describes a group of soldiers n - k + 1 through n.
Your task is to find possible names of n soldiers. Names should match the stolen notes. Each name should be a string that consists of between 1 and 10 English letters, inclusive. The first letter should be uppercase, and all other letters should be lowercase. Names don't have to be existing names — it's allowed to print "Xyzzzdj" or "T" for example.
Find and print any solution. It can be proved that there always exists at least one solution.
Input
The first line of the input contains two integers n and k (2 ≤ k ≤ n ≤ 50) — the number of soldiers and the size of a group respectively.
The second line contains n - k + 1 strings s1, s2, ..., sn - k + 1. The string si is "YES" if the group of soldiers i through i + k - 1 is effective, and "NO" otherwise.
Output
Find any solution satisfying all given conditions. In one line print n space-separated strings, denoting possible names of soldiers in the order. The first letter of each name should be uppercase, while the other letters should be lowercase. Each name should contain English letters only and has length from 1 to 10.
If there are multiple valid solutions, print any of them.
Examples
Input
8 3
NO NO YES YES YES NO
Output
Adam Bob Bob Cpqepqwer Limak Adam Bob Adam
Input
9 8
YES NO
Output
R Q Ccccccccc Ccocc Ccc So Strong Samples Ccc
Input
3 2
NO NO
Output
Na Na Na
Note
In the first sample, there are 8 soldiers. For every 3 consecutive ones we know whether they would be an effective group. Let's analyze the provided sample output:
* First three soldiers (i.e. Adam, Bob, Bob) wouldn't be an effective group because there are two Bobs. Indeed, the string s1 is "NO".
* Soldiers 2 through 4 (Bob, Bob, Cpqepqwer) wouldn't be effective either, and the string s2 is "NO".
* Soldiers 3 through 5 (Bob, Cpqepqwer, Limak) would be effective, and the string s3 is "YES".
* ...,
* Soldiers 6 through 8 (Adam, Bob, Adam) wouldn't be effective, and the string s6 is "NO".
Submitted Solution:
```
from string import ascii_lowercase
n, m = map(int, input().split())
l = list(input().split())
Names= []
start, end =0,m-1
for i in ascii_lowercase.upper():
for j in ascii_lowercase:
Names.append(i+j)
for i in range(0, m-1):
print(Names[i], end=" ")
for i in l:
if i =="YES":
print(Names[end], end=" ")
start += 1
end += 1
else:
print(Names[start], end=" ")
``` | instruction | 0 | 77,234 | 14 | 154,468 |
No | output | 1 | 77,234 | 14 | 154,469 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the army, it isn't easy to form a group of soldiers that will be effective on the battlefield. The communication is crucial and thus no two soldiers should share a name (what would happen if they got an order that Bob is a scouter, if there are two Bobs?).
A group of soldiers is effective if and only if their names are different. For example, a group (John, Bob, Limak) would be effective, while groups (Gary, Bob, Gary) and (Alice, Alice) wouldn't.
You are a spy in the enemy's camp. You noticed n soldiers standing in a row, numbered 1 through n. The general wants to choose a group of k consecutive soldiers. For every k consecutive soldiers, the general wrote down whether they would be an effective group or not.
You managed to steal the general's notes, with n - k + 1 strings s1, s2, ..., sn - k + 1, each either "YES" or "NO".
* The string s1 describes a group of soldiers 1 through k ("YES" if the group is effective, and "NO" otherwise).
* The string s2 describes a group of soldiers 2 through k + 1.
* And so on, till the string sn - k + 1 that describes a group of soldiers n - k + 1 through n.
Your task is to find possible names of n soldiers. Names should match the stolen notes. Each name should be a string that consists of between 1 and 10 English letters, inclusive. The first letter should be uppercase, and all other letters should be lowercase. Names don't have to be existing names — it's allowed to print "Xyzzzdj" or "T" for example.
Find and print any solution. It can be proved that there always exists at least one solution.
Input
The first line of the input contains two integers n and k (2 ≤ k ≤ n ≤ 50) — the number of soldiers and the size of a group respectively.
The second line contains n - k + 1 strings s1, s2, ..., sn - k + 1. The string si is "YES" if the group of soldiers i through i + k - 1 is effective, and "NO" otherwise.
Output
Find any solution satisfying all given conditions. In one line print n space-separated strings, denoting possible names of soldiers in the order. The first letter of each name should be uppercase, while the other letters should be lowercase. Each name should contain English letters only and has length from 1 to 10.
If there are multiple valid solutions, print any of them.
Examples
Input
8 3
NO NO YES YES YES NO
Output
Adam Bob Bob Cpqepqwer Limak Adam Bob Adam
Input
9 8
YES NO
Output
R Q Ccccccccc Ccocc Ccc So Strong Samples Ccc
Input
3 2
NO NO
Output
Na Na Na
Note
In the first sample, there are 8 soldiers. For every 3 consecutive ones we know whether they would be an effective group. Let's analyze the provided sample output:
* First three soldiers (i.e. Adam, Bob, Bob) wouldn't be an effective group because there are two Bobs. Indeed, the string s1 is "NO".
* Soldiers 2 through 4 (Bob, Bob, Cpqepqwer) wouldn't be effective either, and the string s2 is "NO".
* Soldiers 3 through 5 (Bob, Cpqepqwer, Limak) would be effective, and the string s3 is "YES".
* ...,
* Soldiers 6 through 8 (Adam, Bob, Adam) wouldn't be effective, and the string s6 is "NO".
Submitted Solution:
```
import random
n, m = map(int, input().split(' '))
s=input().split(' ')
ans=[i for i in range(n)]
for i in range(m):
ans[i]='A'
for j in range(i):
ans[i]+='a'
if s[0]=='NO':
ans[m-1]=ans[0]
id=m;j=1
for i in range(m,n):
if s[j]=='NO':
ans[i]=ans[i-m+1]
else:
if len(ans[i-1])<=8:
ans[i]=ans[i-1]+chr(random.randrange(0,25)+ord('a'))+chr(random.randrange(0,25)+ord('a'))
else:
ans[i]=ans[i-1]
ans[i]=ans[i][:1]+chr(random.randrange(0,25)+ord('a'))+chr(random.randrange(0,25)+ord('a'))+\
chr(random.randrange(0,25)+ord('a'))+ans[i][5:]
j+=1
for i in ans:
print(i,end=' ')
``` | instruction | 0 | 77,235 | 14 | 154,470 |
No | output | 1 | 77,235 | 14 | 154,471 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the army, it isn't easy to form a group of soldiers that will be effective on the battlefield. The communication is crucial and thus no two soldiers should share a name (what would happen if they got an order that Bob is a scouter, if there are two Bobs?).
A group of soldiers is effective if and only if their names are different. For example, a group (John, Bob, Limak) would be effective, while groups (Gary, Bob, Gary) and (Alice, Alice) wouldn't.
You are a spy in the enemy's camp. You noticed n soldiers standing in a row, numbered 1 through n. The general wants to choose a group of k consecutive soldiers. For every k consecutive soldiers, the general wrote down whether they would be an effective group or not.
You managed to steal the general's notes, with n - k + 1 strings s1, s2, ..., sn - k + 1, each either "YES" or "NO".
* The string s1 describes a group of soldiers 1 through k ("YES" if the group is effective, and "NO" otherwise).
* The string s2 describes a group of soldiers 2 through k + 1.
* And so on, till the string sn - k + 1 that describes a group of soldiers n - k + 1 through n.
Your task is to find possible names of n soldiers. Names should match the stolen notes. Each name should be a string that consists of between 1 and 10 English letters, inclusive. The first letter should be uppercase, and all other letters should be lowercase. Names don't have to be existing names — it's allowed to print "Xyzzzdj" or "T" for example.
Find and print any solution. It can be proved that there always exists at least one solution.
Input
The first line of the input contains two integers n and k (2 ≤ k ≤ n ≤ 50) — the number of soldiers and the size of a group respectively.
The second line contains n - k + 1 strings s1, s2, ..., sn - k + 1. The string si is "YES" if the group of soldiers i through i + k - 1 is effective, and "NO" otherwise.
Output
Find any solution satisfying all given conditions. In one line print n space-separated strings, denoting possible names of soldiers in the order. The first letter of each name should be uppercase, while the other letters should be lowercase. Each name should contain English letters only and has length from 1 to 10.
If there are multiple valid solutions, print any of them.
Examples
Input
8 3
NO NO YES YES YES NO
Output
Adam Bob Bob Cpqepqwer Limak Adam Bob Adam
Input
9 8
YES NO
Output
R Q Ccccccccc Ccocc Ccc So Strong Samples Ccc
Input
3 2
NO NO
Output
Na Na Na
Note
In the first sample, there are 8 soldiers. For every 3 consecutive ones we know whether they would be an effective group. Let's analyze the provided sample output:
* First three soldiers (i.e. Adam, Bob, Bob) wouldn't be an effective group because there are two Bobs. Indeed, the string s1 is "NO".
* Soldiers 2 through 4 (Bob, Bob, Cpqepqwer) wouldn't be effective either, and the string s2 is "NO".
* Soldiers 3 through 5 (Bob, Cpqepqwer, Limak) would be effective, and the string s3 is "YES".
* ...,
* Soldiers 6 through 8 (Adam, Bob, Adam) wouldn't be effective, and the string s6 is "NO".
Submitted Solution:
```
n,k = map(int,input().split())
a = list(input().split())
mem = []
mem2 = []
for i in 'abcdefghijklmnopqrstuvwxyz':
mem.append(i)
mem.append('a'+i)
mem2.append('b'+i)
mem2.append('c'+i)
dp = [-1]*(n)
c = 0
c2 = 0
for i in range(len(a)):
if a[i] == "NO":
if dp[i] == -1:
dp[i] = mem2[c2]
if dp[i+k-1] == -1:
dp[i+k-1] = mem2[c2]
c2 += 1
else:
for j in range(i,i+k):
if (dp[j] == -1):
dp[j] = mem[c]
c += 1
for i in dp:
print(i[0].upper()+i[1:],end=' ')
``` | instruction | 0 | 77,236 | 14 | 154,472 |
No | output | 1 | 77,236 | 14 | 154,473 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have a team of N people. For a particular task, you can pick any non-empty subset of people. The cost of having x people for the task is xk.
Output the sum of costs over all non-empty subsets of people.
Input
Only line of input contains two integers N (1 ≤ N ≤ 109) representing total number of people and k (1 ≤ k ≤ 5000).
Output
Output the sum of costs for all non empty subsets modulo 109 + 7.
Examples
Input
1 1
Output
1
Input
3 2
Output
24
Note
In the first example, there is only one non-empty subset {1} with cost 11 = 1.
In the second example, there are seven non-empty subsets.
- {1} with cost 12 = 1
- {2} with cost 12 = 1
- {1, 2} with cost 22 = 4
- {3} with cost 12 = 1
- {1, 3} with cost 22 = 4
- {2, 3} with cost 22 = 4
- {1, 2, 3} with cost 32 = 9
The total cost is 1 + 1 + 4 + 1 + 4 + 4 + 9 = 24. | instruction | 0 | 77,321 | 14 | 154,642 |
Tags: combinatorics, dp, math
Correct Solution:
```
n, k = map(int, input().split())
m = 0x3b9aca07
r = 0
p = pow(2, n, m)
a = [1] + [0] * k
for i in range(k):
for j in range(i, -1, -1):
a[j + 1] += a[j]
a[j] = a[j] * j % m
for i in range(k + 1):
r += p * a[i]
p = p * 500000004 * (n - i) % m
print(r % m)
``` | output | 1 | 77,321 | 14 | 154,643 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have a team of N people. For a particular task, you can pick any non-empty subset of people. The cost of having x people for the task is xk.
Output the sum of costs over all non-empty subsets of people.
Input
Only line of input contains two integers N (1 ≤ N ≤ 109) representing total number of people and k (1 ≤ k ≤ 5000).
Output
Output the sum of costs for all non empty subsets modulo 109 + 7.
Examples
Input
1 1
Output
1
Input
3 2
Output
24
Note
In the first example, there is only one non-empty subset {1} with cost 11 = 1.
In the second example, there are seven non-empty subsets.
- {1} with cost 12 = 1
- {2} with cost 12 = 1
- {1, 2} with cost 22 = 4
- {3} with cost 12 = 1
- {1, 3} with cost 22 = 4
- {2, 3} with cost 22 = 4
- {1, 2, 3} with cost 32 = 9
The total cost is 1 + 1 + 4 + 1 + 4 + 4 + 9 = 24. | instruction | 0 | 77,322 | 14 | 154,644 |
Tags: combinatorics, dp, math
Correct Solution:
```
n,k = map(int,input().split())
dp = [0 for i in range(k+1)]
mod = 10**9+7
dp[0] = 1
for i in range(k):
for j in range(1,k+1)[::-1]:
dp[j] = (dp[j]*j+dp[j-1]*(n-j+1))%mod
dp[0] = 0
ans = 0
for i in range(k+1):
if n < i:
continue
ans += dp[i]*pow(2,n-i,mod)
ans %= mod
print(ans)
``` | output | 1 | 77,322 | 14 | 154,645 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have a team of N people. For a particular task, you can pick any non-empty subset of people. The cost of having x people for the task is xk.
Output the sum of costs over all non-empty subsets of people.
Input
Only line of input contains two integers N (1 ≤ N ≤ 109) representing total number of people and k (1 ≤ k ≤ 5000).
Output
Output the sum of costs for all non empty subsets modulo 109 + 7.
Examples
Input
1 1
Output
1
Input
3 2
Output
24
Note
In the first example, there is only one non-empty subset {1} with cost 11 = 1.
In the second example, there are seven non-empty subsets.
- {1} with cost 12 = 1
- {2} with cost 12 = 1
- {1, 2} with cost 22 = 4
- {3} with cost 12 = 1
- {1, 3} with cost 22 = 4
- {2, 3} with cost 22 = 4
- {1, 2, 3} with cost 32 = 9
The total cost is 1 + 1 + 4 + 1 + 4 + 4 + 9 = 24. | instruction | 0 | 77,323 | 14 | 154,646 |
Tags: combinatorics, dp, math
Correct Solution:
```
import sys
def I(): return int(sys.stdin.readline().rstrip())
def MI(): return map(int,sys.stdin.readline().rstrip().split())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LI2(): return list(map(int,sys.stdin.readline().rstrip()))
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())
def LS2(): return list(sys.stdin.readline().rstrip())
N,k = MI()
mod = 10**9+7
inv_2 = (mod+1)//2
x = pow(2,N,mod)
X = [0]*(k+1) # X[i] = N_P_i*2^(N-i)
for i in range(k+1):
X[i] = x
x *= (N-i)*inv_2
x %= mod
coefficient = [0]*(k+1)
# coefficient[i] = f(x)に対して、「微分して*xする」をi回繰り返した際の係数
# メモリ節約のため、i省略
coefficient[0] = 1
for _ in range(k):
for j in range(k,-1,-1):
coefficient[j] = coefficient[j]*j+coefficient[j-1]
coefficient[j] %= mod
ans = 0
for i in range(1,k+1):
ans += coefficient[i]*X[i]
ans %= mod
print(ans)
``` | output | 1 | 77,323 | 14 | 154,647 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have a team of N people. For a particular task, you can pick any non-empty subset of people. The cost of having x people for the task is xk.
Output the sum of costs over all non-empty subsets of people.
Input
Only line of input contains two integers N (1 ≤ N ≤ 109) representing total number of people and k (1 ≤ k ≤ 5000).
Output
Output the sum of costs for all non empty subsets modulo 109 + 7.
Examples
Input
1 1
Output
1
Input
3 2
Output
24
Note
In the first example, there is only one non-empty subset {1} with cost 11 = 1.
In the second example, there are seven non-empty subsets.
- {1} with cost 12 = 1
- {2} with cost 12 = 1
- {1, 2} with cost 22 = 4
- {3} with cost 12 = 1
- {1, 3} with cost 22 = 4
- {2, 3} with cost 22 = 4
- {1, 2, 3} with cost 32 = 9
The total cost is 1 + 1 + 4 + 1 + 4 + 4 + 9 = 24. | instruction | 0 | 77,324 | 14 | 154,648 |
Tags: combinatorics, dp, math
Correct Solution:
```
n, k = map(int, input().split())
m = int(1e9+7)
r = 0
p = pow(2, n, m)
a = [1] + [0] * k
for i in range(k):
for j in range(i, -1, -1):
a[j+1] += a[j]
a[j] = a[j]*j % m
for i in range(k + 1):
r += p*a[i]
p = p*500000004*(n - i) % m
print(r % m)
``` | output | 1 | 77,324 | 14 | 154,649 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have a team of N people. For a particular task, you can pick any non-empty subset of people. The cost of having x people for the task is xk.
Output the sum of costs over all non-empty subsets of people.
Input
Only line of input contains two integers N (1 ≤ N ≤ 109) representing total number of people and k (1 ≤ k ≤ 5000).
Output
Output the sum of costs for all non empty subsets modulo 109 + 7.
Examples
Input
1 1
Output
1
Input
3 2
Output
24
Note
In the first example, there is only one non-empty subset {1} with cost 11 = 1.
In the second example, there are seven non-empty subsets.
- {1} with cost 12 = 1
- {2} with cost 12 = 1
- {1, 2} with cost 22 = 4
- {3} with cost 12 = 1
- {1, 3} with cost 22 = 4
- {2, 3} with cost 22 = 4
- {1, 2, 3} with cost 32 = 9
The total cost is 1 + 1 + 4 + 1 + 4 + 4 + 9 = 24. | instruction | 0 | 77,325 | 14 | 154,650 |
Tags: combinatorics, dp, math
Correct Solution:
```
# ############################## import
# def stirling2_list(n, mod=10 ** 9 + 7):
# if not n:
# return [0]
# res = [0, 1]
# for i in range(n - 1):
# res = [0, 1] + [(res[j - 1] + j * res[j]) % mod for j in range(2, 2 + i)] + [1]
# return res
# Explain:
# ans = \sum_{i=1}^{n} \binom{n}{i} i^k
# Notice that (1+x)^n = \sum_{i=0}^{n} \binom{n}{i} x^i
# differential and multiply by x on both side, we can get
# n(1+x)^{n-1}x=\sum_{i=0}^{n}\binom{n}{i}ix^i
# we can keep doing this process to get \sum_{i=0}^{n}\binom{n}{i}i^kx^i
# and the answer is the left side function, with x = 1
#
# Let f_0(x) = (1+x)^n
# and f_m(x) = f_{m-1}'(x)x
# so the answer is f_{k}(1)
# We calculate the first few of patterns
# We can observe that:
# f_1 = f_0'x
# f_2 = f_0'x + 1f_0''x^2
# f_3 = f_0'x + 3f_0''x^2 + f_0'''x^3
# f_4 = f_0'x + 7f_0''x^2 + 6f_0'''x^3 + f_0''''x^4
# The coefficients is Stirling numbers of the second kind
# And f_0 with differentiating k times is just
# n(n-1)(n-2)...(n-(k-1))(1+x)^{n-k}
# We can find them out in one iteration
# ############################## main
MOD = 10 ** 9 + 7
INV = 500000004
n, k = map(int, input().split())
# (1+x)^n, n(1+x)^{n-1}, n(n-1)(1+x)^{n-2}, ...
# 2^n, n*2^{n-1}, n(n-1)*2^{n-2}, ...
# f_4 = f_0' + 7f_0'' + 6f_0''' + f_0''''
d = 1
p = pow(2, n, MOD)
ans = 0
stirling2_list = [0, 1]
for i in range(k - 1):
stirling2_list = [0, 1] + [(stirling2_list[j - 1] + j * stirling2_list[j]) % MOD for j in range(2, 2 + i)] + [1]
for stirling in stirling2_list:
ans = (ans + stirling * d * p) % MOD
d = d * n % MOD
n -= 1
p = p * INV % MOD
print(ans)
``` | output | 1 | 77,325 | 14 | 154,651 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have a team of N people. For a particular task, you can pick any non-empty subset of people. The cost of having x people for the task is xk.
Output the sum of costs over all non-empty subsets of people.
Input
Only line of input contains two integers N (1 ≤ N ≤ 109) representing total number of people and k (1 ≤ k ≤ 5000).
Output
Output the sum of costs for all non empty subsets modulo 109 + 7.
Examples
Input
1 1
Output
1
Input
3 2
Output
24
Note
In the first example, there is only one non-empty subset {1} with cost 11 = 1.
In the second example, there are seven non-empty subsets.
- {1} with cost 12 = 1
- {2} with cost 12 = 1
- {1, 2} with cost 22 = 4
- {3} with cost 12 = 1
- {1, 3} with cost 22 = 4
- {2, 3} with cost 22 = 4
- {1, 2, 3} with cost 32 = 9
The total cost is 1 + 1 + 4 + 1 + 4 + 4 + 9 = 24. | instruction | 0 | 77,326 | 14 | 154,652 |
Tags: combinatorics, dp, math
Correct Solution:
```
n, k = map(int, input().split())
m = 0x3b9aca07
r = 0
p = pow(2, n, m)
a = [1] + [0] * k
for i in range(k):
for j in range(i, -1, -1):
a[j + 1] += a[j]
a[j] = a[j] * j % m
for i in range(k + 1):
r = (r + p * a[i]) % m
p = p * 500000004 * (n - i) % m
print(r)
``` | output | 1 | 77,326 | 14 | 154,653 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have a team of N people. For a particular task, you can pick any non-empty subset of people. The cost of having x people for the task is xk.
Output the sum of costs over all non-empty subsets of people.
Input
Only line of input contains two integers N (1 ≤ N ≤ 109) representing total number of people and k (1 ≤ k ≤ 5000).
Output
Output the sum of costs for all non empty subsets modulo 109 + 7.
Examples
Input
1 1
Output
1
Input
3 2
Output
24
Note
In the first example, there is only one non-empty subset {1} with cost 11 = 1.
In the second example, there are seven non-empty subsets.
- {1} with cost 12 = 1
- {2} with cost 12 = 1
- {1, 2} with cost 22 = 4
- {3} with cost 12 = 1
- {1, 3} with cost 22 = 4
- {2, 3} with cost 22 = 4
- {1, 2, 3} with cost 32 = 9
The total cost is 1 + 1 + 4 + 1 + 4 + 4 + 9 = 24. | instruction | 0 | 77,327 | 14 | 154,654 |
Tags: combinatorics, dp, math
Correct Solution:
```
n, k = map(int, input().split())
m = 0x3b9aca07
v = 500000004
r = 0
p = pow(2, n, m)
a = [1] + [0] * k
for i in range(k):
for j in range(i, -1, -1):
a[j + 1] += a[j]
a[j] = a[j] * j % m
for i in range(k + 1):
r = (r + p * a[i]) % m
p = p * v * (n - i) % m
print(r)
``` | output | 1 | 77,327 | 14 | 154,655 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have a team of N people. For a particular task, you can pick any non-empty subset of people. The cost of having x people for the task is xk.
Output the sum of costs over all non-empty subsets of people.
Input
Only line of input contains two integers N (1 ≤ N ≤ 109) representing total number of people and k (1 ≤ k ≤ 5000).
Output
Output the sum of costs for all non empty subsets modulo 109 + 7.
Examples
Input
1 1
Output
1
Input
3 2
Output
24
Note
In the first example, there is only one non-empty subset {1} with cost 11 = 1.
In the second example, there are seven non-empty subsets.
- {1} with cost 12 = 1
- {2} with cost 12 = 1
- {1, 2} with cost 22 = 4
- {3} with cost 12 = 1
- {1, 3} with cost 22 = 4
- {2, 3} with cost 22 = 4
- {1, 2, 3} with cost 32 = 9
The total cost is 1 + 1 + 4 + 1 + 4 + 4 + 9 = 24. | instruction | 0 | 77,328 | 14 | 154,656 |
Tags: combinatorics, dp, math
Correct Solution:
```
n, k = map(int, input().split())
m = int(1e9 + 7)
r = 0
p = pow(2, n, m)
a = [1] + [0] * k
for i in range(k):
for j in range(i, -1, -1):
a[j + 1] += a[j]
a[j] = a[j] * j % m
for i in range(k + 1):
r = (r + p * a[i]) % m
p = p * 500000004 * (n - i) % m
print(r)
``` | output | 1 | 77,328 | 14 | 154,657 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Phoenix is trying to take a photo of his n friends with labels 1, 2, ..., n who are lined up in a row in a special order. But before he can take the photo, his friends get distracted by a duck and mess up their order.
Now, Phoenix must restore the order but he doesn't remember completely! He only remembers that the i-th friend from the left had a label between a_i and b_i inclusive. Does there exist a unique way to order his friends based of his memory?
Input
The first line contains one integer n (1 ≤ n ≤ 2⋅10^5) — the number of friends.
The i-th of the next n lines contain two integers a_i and b_i (1 ≤ a_i ≤ b_i ≤ n) — Phoenix's memory of the i-th position from the left.
It is guaranteed that Phoenix's memory is valid so there is at least one valid ordering.
Output
If Phoenix can reorder his friends in a unique order, print YES followed by n integers — the i-th integer should be the label of the i-th friend from the left.
Otherwise, print NO. Then, print any two distinct valid orderings on the following two lines. If are multiple solutions, print any.
Examples
Input
4
4 4
1 3
2 4
3 4
Output
YES
4 1 2 3
Input
4
1 3
2 4
3 4
2 3
Output
NO
1 3 4 2
1 2 4 3
Submitted Solution:
```
from heapq import *
import sys
sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def SI(): return sys.stdin.readline()[:-1]
def main():
n=II()
lri=[]
# i...seat index
for i in range(n):
l,r=MI()
heappush(lri,(l-1,r-1,i))
# j...member index
rli=[]
can=[-1]
ans=[0]*n
for j in range(n):
while lri and lri[0][0]<=j:
l,r,i=heappop(lri)
heappush(rli,(r,l,i))
r,l,i=heappop(rli)
#print(r,l,i,rli)
if r>j and rli and rli[0][1]<=j:can=[i,rli[0][2]]
ans[i]=j+1
if can[0]==-1:
print("YES")
print(*ans)
else:
print("NO")
print(*ans)
i0,i1=can
ans[i0],ans[i1]=ans[i1],ans[i0]
print(*ans)
main()
``` | instruction | 0 | 77,705 | 14 | 155,410 |
No | output | 1 | 77,705 | 14 | 155,411 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Phoenix is trying to take a photo of his n friends with labels 1, 2, ..., n who are lined up in a row in a special order. But before he can take the photo, his friends get distracted by a duck and mess up their order.
Now, Phoenix must restore the order but he doesn't remember completely! He only remembers that the i-th friend from the left had a label between a_i and b_i inclusive. Does there exist a unique way to order his friends based of his memory?
Input
The first line contains one integer n (1 ≤ n ≤ 2⋅10^5) — the number of friends.
The i-th of the next n lines contain two integers a_i and b_i (1 ≤ a_i ≤ b_i ≤ n) — Phoenix's memory of the i-th position from the left.
It is guaranteed that Phoenix's memory is valid so there is at least one valid ordering.
Output
If Phoenix can reorder his friends in a unique order, print YES followed by n integers — the i-th integer should be the label of the i-th friend from the left.
Otherwise, print NO. Then, print any two distinct valid orderings on the following two lines. If are multiple solutions, print any.
Examples
Input
4
4 4
1 3
2 4
3 4
Output
YES
4 1 2 3
Input
4
1 3
2 4
3 4
2 3
Output
NO
1 3 4 2
1 2 4 3
Submitted Solution:
```
# arr = list(map(int, input().split()))
#
class Node:
def __init__(self, a, b , i):
self.a = a
self.b = b
self.d = abs(a-b)
self.idx = i
t = int(input())
i = 0
array = list()
while i < t:
[n, k] = list(map(int, input().split()))
array.append(Node(n, k, i))
i += 1
array.sort(key=lambda x: x.d)
table = set()
arr = [0] * t
ok = True
if array[0].d != 0:
ok = False
table.add(array[0].a)
arr[array[0].idx] = array[0].a
for j in range(1, t):
if array[j].a not in table:
table.add(array[j].a)
arr[array[j].idx] = array[j].a
elif array[j].b not in table:
table.add(array[j].b)
arr[array[j].idx] = array[j].b
if array[j].d - array[j-1].d > 1:
ok = False
if ok:
print("YES")
for a in arr:
print(a, end=" ")
else:
print("NO")
for a in arr:
print(a, end=" ")
print()
table = set()
arr = [0] * t
for j in range(0, t):
if array[j].b not in table:
table.add(array[j].b)
arr[array[j].idx] = array[j].b
elif array[j].a not in table:
table.add(array[j].a)
arr[array[j].idx] = array[j].a
for a in arr:
print(a, end=" ")
``` | instruction | 0 | 77,706 | 14 | 155,412 |
No | output | 1 | 77,706 | 14 | 155,413 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Phoenix is trying to take a photo of his n friends with labels 1, 2, ..., n who are lined up in a row in a special order. But before he can take the photo, his friends get distracted by a duck and mess up their order.
Now, Phoenix must restore the order but he doesn't remember completely! He only remembers that the i-th friend from the left had a label between a_i and b_i inclusive. Does there exist a unique way to order his friends based of his memory?
Input
The first line contains one integer n (1 ≤ n ≤ 2⋅10^5) — the number of friends.
The i-th of the next n lines contain two integers a_i and b_i (1 ≤ a_i ≤ b_i ≤ n) — Phoenix's memory of the i-th position from the left.
It is guaranteed that Phoenix's memory is valid so there is at least one valid ordering.
Output
If Phoenix can reorder his friends in a unique order, print YES followed by n integers — the i-th integer should be the label of the i-th friend from the left.
Otherwise, print NO. Then, print any two distinct valid orderings on the following two lines. If are multiple solutions, print any.
Examples
Input
4
4 4
1 3
2 4
3 4
Output
YES
4 1 2 3
Input
4
1 3
2 4
3 4
2 3
Output
NO
1 3 4 2
1 2 4 3
Submitted Solution:
```
def gen(idx,used):
#nonlocal sol
#nonlocal req
if idx == T:
sol.append(used)
if len(sol) == req:
return True
else:
return False
#print(idx)
l = arr[idx][0]
h = arr[idx][1]
for i in range(l,h+1):
if i not in used:
nx = {k:"" for k in used.keys()}
nx[i] = ""
b = gen(idx+1,nx)
if b:
return True
return False
T = int(input())
sol = []
arr = []
exp = set()
flag = True
req = 1
for case in range(T):
l,h = [int(x) for x in input().split()]
arr.append((l,h,case))
arr = sorted(arr, key = lambda x : x[1] - x[0])
for (l,h,_) in arr:
if (l,h) in exp:
print("NO")
flag = False
req = 2
gen(0,{})
#print(arr)
#print(sol)
for s in sol:
order = list(s.keys())
idxs = list([x[2] for x in arr])
z = sorted([(a,b) for a,b in zip(order,idxs)],key = lambda x:x[1])
print(" ".join([str(k[0]) for k in z]))
up = set()
for e in exp:
if l <= e[1]+1 and l >= e[0] and h >= e[1]+1:
up.add((e[0],h))
if h <= e[1] and h >= e[0]-1 and l <= e[0]-1:
up.add((l,e[1]))
exp.add((l,h))
exp.update(up)
#print(exp)
if flag:
print("YES")
req = 1
gen(0,{})
#print(arr)
#print(sol)
order = list(sol[0].keys())
idxs = list([x[2] for x in arr])
z = sorted([(a,b) for a,b in zip(order,idxs)],key = lambda x:x[1])
print(" ".join([str(k[0]) for k in z]))
``` | instruction | 0 | 77,707 | 14 | 155,414 |
No | output | 1 | 77,707 | 14 | 155,415 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Phoenix is trying to take a photo of his n friends with labels 1, 2, ..., n who are lined up in a row in a special order. But before he can take the photo, his friends get distracted by a duck and mess up their order.
Now, Phoenix must restore the order but he doesn't remember completely! He only remembers that the i-th friend from the left had a label between a_i and b_i inclusive. Does there exist a unique way to order his friends based of his memory?
Input
The first line contains one integer n (1 ≤ n ≤ 2⋅10^5) — the number of friends.
The i-th of the next n lines contain two integers a_i and b_i (1 ≤ a_i ≤ b_i ≤ n) — Phoenix's memory of the i-th position from the left.
It is guaranteed that Phoenix's memory is valid so there is at least one valid ordering.
Output
If Phoenix can reorder his friends in a unique order, print YES followed by n integers — the i-th integer should be the label of the i-th friend from the left.
Otherwise, print NO. Then, print any two distinct valid orderings on the following two lines. If are multiple solutions, print any.
Examples
Input
4
4 4
1 3
2 4
3 4
Output
YES
4 1 2 3
Input
4
1 3
2 4
3 4
2 3
Output
NO
1 3 4 2
1 2 4 3
Submitted Solution:
```
import math
def task(n, a, b):
intervals = []
results = []
for i in range(0, n):
intervals.append({"i": i, "a": a[i], "b": b[i]})
results.append(None)
intervals.sort(key=lambda x: (x['a'], x['b']))
# print(intervals)
# print(results)
can = True
mn = 0
for i in range(0, n):
if can and mn == intervals[i]['a']:
can = False
failedIndex1 = intervals[i - 1]['i']
failedIndex2 = intervals[i]['i']
results[intervals[i]['i']] = mn + 1
mn += 1
if can:
print('YES')
print(results)
else:
print('NO')
print(results)
tmp = results[failedIndex1]
results[failedIndex1] = results[failedIndex2]
results[failedIndex2] = tmp
print(results)
n = int(input())
a = []
b = []
for i in range(0, n):
l, r = map(int, input().split())
a.append(l)
b.append(r)
task(n, a, b)
``` | instruction | 0 | 77,708 | 14 | 155,416 |
No | output | 1 | 77,708 | 14 | 155,417 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Emily's birthday is next week and Jack has decided to buy a present for her. He knows she loves books so he goes to the local bookshop, where there are n books on sale from one of m genres.
In the bookshop, Jack decides to buy two books of different genres.
Based on the genre of books on sale in the shop, find the number of options available to Jack for choosing two books of different genres for Emily. Options are considered different if they differ in at least one book.
The books are given by indices of their genres. The genres are numbered from 1 to m.
Input
The first line contains two positive integers n and m (2 ≤ n ≤ 2·105, 2 ≤ m ≤ 10) — the number of books in the bookstore and the number of genres.
The second line contains a sequence a1, a2, ..., an, where ai (1 ≤ ai ≤ m) equals the genre of the i-th book.
It is guaranteed that for each genre there is at least one book of that genre.
Output
Print the only integer — the number of ways in which Jack can choose books.
It is guaranteed that the answer doesn't exceed the value 2·109.
Examples
Input
4 3
2 1 3 1
Output
5
Input
7 4
4 2 3 1 2 4 3
Output
18
Note
The answer to the first test sample equals 5 as Sasha can choose:
1. the first and second books,
2. the first and third books,
3. the first and fourth books,
4. the second and third books,
5. the third and fourth books. | instruction | 0 | 77,873 | 14 | 155,746 |
Tags: constructive algorithms, implementation
Correct Solution:
```
from functools import *
n, m = map(int, input().split())
cnt = [0] * (m + 1)
a = list(map(int, input().split()))
for x in a:
cnt[x] += 1
print(reduce(lambda res, x: res + x * (n - x), cnt, 0) // 2)
``` | output | 1 | 77,873 | 14 | 155,747 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Emily's birthday is next week and Jack has decided to buy a present for her. He knows she loves books so he goes to the local bookshop, where there are n books on sale from one of m genres.
In the bookshop, Jack decides to buy two books of different genres.
Based on the genre of books on sale in the shop, find the number of options available to Jack for choosing two books of different genres for Emily. Options are considered different if they differ in at least one book.
The books are given by indices of their genres. The genres are numbered from 1 to m.
Input
The first line contains two positive integers n and m (2 ≤ n ≤ 2·105, 2 ≤ m ≤ 10) — the number of books in the bookstore and the number of genres.
The second line contains a sequence a1, a2, ..., an, where ai (1 ≤ ai ≤ m) equals the genre of the i-th book.
It is guaranteed that for each genre there is at least one book of that genre.
Output
Print the only integer — the number of ways in which Jack can choose books.
It is guaranteed that the answer doesn't exceed the value 2·109.
Examples
Input
4 3
2 1 3 1
Output
5
Input
7 4
4 2 3 1 2 4 3
Output
18
Note
The answer to the first test sample equals 5 as Sasha can choose:
1. the first and second books,
2. the first and third books,
3. the first and fourth books,
4. the second and third books,
5. the third and fourth books. | instruction | 0 | 77,874 | 14 | 155,748 |
Tags: constructive algorithms, implementation
Correct Solution:
```
n, m = map(int, input().split())
a = list(map(int, input().split()))
ans = 0
t = n
for i in range(1, m):
cai = a.count(i)
ans += cai * (t - cai)
t -= cai
print(ans)
``` | output | 1 | 77,874 | 14 | 155,749 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Emily's birthday is next week and Jack has decided to buy a present for her. He knows she loves books so he goes to the local bookshop, where there are n books on sale from one of m genres.
In the bookshop, Jack decides to buy two books of different genres.
Based on the genre of books on sale in the shop, find the number of options available to Jack for choosing two books of different genres for Emily. Options are considered different if they differ in at least one book.
The books are given by indices of their genres. The genres are numbered from 1 to m.
Input
The first line contains two positive integers n and m (2 ≤ n ≤ 2·105, 2 ≤ m ≤ 10) — the number of books in the bookstore and the number of genres.
The second line contains a sequence a1, a2, ..., an, where ai (1 ≤ ai ≤ m) equals the genre of the i-th book.
It is guaranteed that for each genre there is at least one book of that genre.
Output
Print the only integer — the number of ways in which Jack can choose books.
It is guaranteed that the answer doesn't exceed the value 2·109.
Examples
Input
4 3
2 1 3 1
Output
5
Input
7 4
4 2 3 1 2 4 3
Output
18
Note
The answer to the first test sample equals 5 as Sasha can choose:
1. the first and second books,
2. the first and third books,
3. the first and fourth books,
4. the second and third books,
5. the third and fourth books. | instruction | 0 | 77,875 | 14 | 155,750 |
Tags: constructive algorithms, implementation
Correct Solution:
```
n, m = [int(x) for x in input().split()]
# inisialisasi array untuk menghitung bayak buku setiap genre
cnt = [0 for x in range(m)]
for x in input().split():
# kurangi dengan satu agar nomor genre dimulai dari 0-(m-1)
num = int(x) - 1
cnt[num] += 1
ans = 0
for i in range(m):
for j in range(i):
ans = ans + cnt[i] * cnt[j]
print(ans)
``` | output | 1 | 77,875 | 14 | 155,751 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Emily's birthday is next week and Jack has decided to buy a present for her. He knows she loves books so he goes to the local bookshop, where there are n books on sale from one of m genres.
In the bookshop, Jack decides to buy two books of different genres.
Based on the genre of books on sale in the shop, find the number of options available to Jack for choosing two books of different genres for Emily. Options are considered different if they differ in at least one book.
The books are given by indices of their genres. The genres are numbered from 1 to m.
Input
The first line contains two positive integers n and m (2 ≤ n ≤ 2·105, 2 ≤ m ≤ 10) — the number of books in the bookstore and the number of genres.
The second line contains a sequence a1, a2, ..., an, where ai (1 ≤ ai ≤ m) equals the genre of the i-th book.
It is guaranteed that for each genre there is at least one book of that genre.
Output
Print the only integer — the number of ways in which Jack can choose books.
It is guaranteed that the answer doesn't exceed the value 2·109.
Examples
Input
4 3
2 1 3 1
Output
5
Input
7 4
4 2 3 1 2 4 3
Output
18
Note
The answer to the first test sample equals 5 as Sasha can choose:
1. the first and second books,
2. the first and third books,
3. the first and fourth books,
4. the second and third books,
5. the third and fourth books. | instruction | 0 | 77,876 | 14 | 155,752 |
Tags: constructive algorithms, implementation
Correct Solution:
```
n, m = map(int, input().split())
books_per_genre = [0]*m
books = list(map(int, input().split()))
for book in books:
books_per_genre[book-1] += 1
result = 0
used = 0
for genre in books_per_genre:
result += (genre*(n-genre-used))
used += genre
print(result)
``` | output | 1 | 77,876 | 14 | 155,753 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Emily's birthday is next week and Jack has decided to buy a present for her. He knows she loves books so he goes to the local bookshop, where there are n books on sale from one of m genres.
In the bookshop, Jack decides to buy two books of different genres.
Based on the genre of books on sale in the shop, find the number of options available to Jack for choosing two books of different genres for Emily. Options are considered different if they differ in at least one book.
The books are given by indices of their genres. The genres are numbered from 1 to m.
Input
The first line contains two positive integers n and m (2 ≤ n ≤ 2·105, 2 ≤ m ≤ 10) — the number of books in the bookstore and the number of genres.
The second line contains a sequence a1, a2, ..., an, where ai (1 ≤ ai ≤ m) equals the genre of the i-th book.
It is guaranteed that for each genre there is at least one book of that genre.
Output
Print the only integer — the number of ways in which Jack can choose books.
It is guaranteed that the answer doesn't exceed the value 2·109.
Examples
Input
4 3
2 1 3 1
Output
5
Input
7 4
4 2 3 1 2 4 3
Output
18
Note
The answer to the first test sample equals 5 as Sasha can choose:
1. the first and second books,
2. the first and third books,
3. the first and fourth books,
4. the second and third books,
5. the third and fourth books. | instruction | 0 | 77,877 | 14 | 155,754 |
Tags: constructive algorithms, implementation
Correct Solution:
```
duplicated_keys = {}
def calculate_chinh_hop_of_2(number_books):
return int(number_books * (number_books - 1) / 2)
number_books, number_genders = list(map(int, input().split()))
number_data = list(map(int, input().split()))
number_of_choosing_books = calculate_chinh_hop_of_2(number_books)
# get books for per gender
for book in number_data:
if book not in duplicated_keys:
duplicated_keys[book] = 1
else:
duplicated_keys[book] += 1
for value in duplicated_keys.values():
number_of_choosing_books -= calculate_chinh_hop_of_2(value)
print(number_of_choosing_books)
``` | output | 1 | 77,877 | 14 | 155,755 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Emily's birthday is next week and Jack has decided to buy a present for her. He knows she loves books so he goes to the local bookshop, where there are n books on sale from one of m genres.
In the bookshop, Jack decides to buy two books of different genres.
Based on the genre of books on sale in the shop, find the number of options available to Jack for choosing two books of different genres for Emily. Options are considered different if they differ in at least one book.
The books are given by indices of their genres. The genres are numbered from 1 to m.
Input
The first line contains two positive integers n and m (2 ≤ n ≤ 2·105, 2 ≤ m ≤ 10) — the number of books in the bookstore and the number of genres.
The second line contains a sequence a1, a2, ..., an, where ai (1 ≤ ai ≤ m) equals the genre of the i-th book.
It is guaranteed that for each genre there is at least one book of that genre.
Output
Print the only integer — the number of ways in which Jack can choose books.
It is guaranteed that the answer doesn't exceed the value 2·109.
Examples
Input
4 3
2 1 3 1
Output
5
Input
7 4
4 2 3 1 2 4 3
Output
18
Note
The answer to the first test sample equals 5 as Sasha can choose:
1. the first and second books,
2. the first and third books,
3. the first and fourth books,
4. the second and third books,
5. the third and fourth books. | instruction | 0 | 77,878 | 14 | 155,756 |
Tags: constructive algorithms, implementation
Correct Solution:
```
n,m = map(int, input().split())
l = list(map(int, input().split()))
num = [0]*int(2*1e5+5)
for i in l:
num[i] += 1
ans = n*(n-1)//2
for i in num:
ans -= i*(i-1)//2
print(ans)
``` | output | 1 | 77,878 | 14 | 155,757 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Emily's birthday is next week and Jack has decided to buy a present for her. He knows she loves books so he goes to the local bookshop, where there are n books on sale from one of m genres.
In the bookshop, Jack decides to buy two books of different genres.
Based on the genre of books on sale in the shop, find the number of options available to Jack for choosing two books of different genres for Emily. Options are considered different if they differ in at least one book.
The books are given by indices of their genres. The genres are numbered from 1 to m.
Input
The first line contains two positive integers n and m (2 ≤ n ≤ 2·105, 2 ≤ m ≤ 10) — the number of books in the bookstore and the number of genres.
The second line contains a sequence a1, a2, ..., an, where ai (1 ≤ ai ≤ m) equals the genre of the i-th book.
It is guaranteed that for each genre there is at least one book of that genre.
Output
Print the only integer — the number of ways in which Jack can choose books.
It is guaranteed that the answer doesn't exceed the value 2·109.
Examples
Input
4 3
2 1 3 1
Output
5
Input
7 4
4 2 3 1 2 4 3
Output
18
Note
The answer to the first test sample equals 5 as Sasha can choose:
1. the first and second books,
2. the first and third books,
3. the first and fourth books,
4. the second and third books,
5. the third and fourth books. | instruction | 0 | 77,879 | 14 | 155,758 |
Tags: constructive algorithms, implementation
Correct Solution:
```
n,m=map(int,input().split())
arr=list(map(int,input().split()))
arr2=[0]*m
ans=0
for i in range(n):
arr2[arr[i]-1]+=1
for i in range(m):
for j in range(i+1,m):
ans+=arr2[i]*arr2[j]
print(ans)
``` | output | 1 | 77,879 | 14 | 155,759 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Emily's birthday is next week and Jack has decided to buy a present for her. He knows she loves books so he goes to the local bookshop, where there are n books on sale from one of m genres.
In the bookshop, Jack decides to buy two books of different genres.
Based on the genre of books on sale in the shop, find the number of options available to Jack for choosing two books of different genres for Emily. Options are considered different if they differ in at least one book.
The books are given by indices of their genres. The genres are numbered from 1 to m.
Input
The first line contains two positive integers n and m (2 ≤ n ≤ 2·105, 2 ≤ m ≤ 10) — the number of books in the bookstore and the number of genres.
The second line contains a sequence a1, a2, ..., an, where ai (1 ≤ ai ≤ m) equals the genre of the i-th book.
It is guaranteed that for each genre there is at least one book of that genre.
Output
Print the only integer — the number of ways in which Jack can choose books.
It is guaranteed that the answer doesn't exceed the value 2·109.
Examples
Input
4 3
2 1 3 1
Output
5
Input
7 4
4 2 3 1 2 4 3
Output
18
Note
The answer to the first test sample equals 5 as Sasha can choose:
1. the first and second books,
2. the first and third books,
3. the first and fourth books,
4. the second and third books,
5. the third and fourth books. | instruction | 0 | 77,880 | 14 | 155,760 |
Tags: constructive algorithms, implementation
Correct Solution:
```
n, m = map(int, input().split())
a = [int(x) for x in input().split()]
# a = list(map(int, input().split()))
c = [0] * 11
ans = 0
for i in range(n):
c[a[i]] += 1
for i in range(1, m):
for j in range(i + 1, m + 1):
ans += c[i] * c[j]
print(ans)
``` | output | 1 | 77,880 | 14 | 155,761 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.