message stringlengths 2 22.7k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 145 109k | cluster float64 9 9 | __index_level_0__ int64 290 217k |
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
After a hard day Vitaly got very hungry and he wants to eat his favorite potato pie. But it's not that simple. Vitaly is in the first room of the house with n room located in a line and numbered starting from one from left to right. You can go from the first room to the second room, from the second room to the third room and so on — you can go from the (n - 1)-th room to the n-th room. Thus, you can go to room x only from room x - 1.
The potato pie is located in the n-th room and Vitaly needs to go there.
Each pair of consecutive rooms has a door between them. In order to go to room x from room x - 1, you need to open the door between the rooms with the corresponding key.
In total the house has several types of doors (represented by uppercase Latin letters) and several types of keys (represented by lowercase Latin letters). The key of type t can open the door of type T if and only if t and T are the same letter, written in different cases. For example, key f can open door F.
Each of the first n - 1 rooms contains exactly one key of some type that Vitaly can use to get to next rooms. Once the door is open with some key, Vitaly won't get the key from the keyhole but he will immediately run into the next room. In other words, each key can open no more than one door.
Vitaly realizes that he may end up in some room without the key that opens the door to the next room. Before the start his run for the potato pie Vitaly can buy any number of keys of any type that is guaranteed to get to room n.
Given the plan of the house, Vitaly wants to know what is the minimum number of keys he needs to buy to surely get to the room n, which has a delicious potato pie. Write a program that will help Vitaly find out this number.
Input
The first line of the input contains a positive integer n (2 ≤ n ≤ 105) — the number of rooms in the house.
The second line of the input contains string s of length 2·n - 2. Let's number the elements of the string from left to right, starting from one.
The odd positions in the given string s contain lowercase Latin letters — the types of the keys that lie in the corresponding rooms. Thus, each odd position i of the given string s contains a lowercase Latin letter — the type of the key that lies in room number (i + 1) / 2.
The even positions in the given string contain uppercase Latin letters — the types of doors between the rooms. Thus, each even position i of the given string s contains an uppercase letter — the type of the door that leads from room i / 2 to room i / 2 + 1.
Output
Print the only integer — the minimum number of keys that Vitaly needs to buy to surely get from room one to room n.
Examples
Input
3
aAbB
Output
0
Input
4
aBaCaB
Output
3
Input
5
xYyXzZaZ
Output
2 | instruction | 0 | 105,659 | 9 | 211,318 |
Tags: greedy, hashing, strings
Correct Solution:
```
n = int(input())
s = input()
need = 0
keys = {c: 0 for c in 'abcdefghijklmnopqrstuvwxyz'}
for c in s:
if c.islower():
keys[c] += 1
else:
c = c.lower()
if keys[c]:
keys[c] -= 1
else:
need += 1
print(need)
``` | output | 1 | 105,659 | 9 | 211,319 |
Provide tags and a correct Python 3 solution for this coding contest problem.
After a hard day Vitaly got very hungry and he wants to eat his favorite potato pie. But it's not that simple. Vitaly is in the first room of the house with n room located in a line and numbered starting from one from left to right. You can go from the first room to the second room, from the second room to the third room and so on — you can go from the (n - 1)-th room to the n-th room. Thus, you can go to room x only from room x - 1.
The potato pie is located in the n-th room and Vitaly needs to go there.
Each pair of consecutive rooms has a door between them. In order to go to room x from room x - 1, you need to open the door between the rooms with the corresponding key.
In total the house has several types of doors (represented by uppercase Latin letters) and several types of keys (represented by lowercase Latin letters). The key of type t can open the door of type T if and only if t and T are the same letter, written in different cases. For example, key f can open door F.
Each of the first n - 1 rooms contains exactly one key of some type that Vitaly can use to get to next rooms. Once the door is open with some key, Vitaly won't get the key from the keyhole but he will immediately run into the next room. In other words, each key can open no more than one door.
Vitaly realizes that he may end up in some room without the key that opens the door to the next room. Before the start his run for the potato pie Vitaly can buy any number of keys of any type that is guaranteed to get to room n.
Given the plan of the house, Vitaly wants to know what is the minimum number of keys he needs to buy to surely get to the room n, which has a delicious potato pie. Write a program that will help Vitaly find out this number.
Input
The first line of the input contains a positive integer n (2 ≤ n ≤ 105) — the number of rooms in the house.
The second line of the input contains string s of length 2·n - 2. Let's number the elements of the string from left to right, starting from one.
The odd positions in the given string s contain lowercase Latin letters — the types of the keys that lie in the corresponding rooms. Thus, each odd position i of the given string s contains a lowercase Latin letter — the type of the key that lies in room number (i + 1) / 2.
The even positions in the given string contain uppercase Latin letters — the types of doors between the rooms. Thus, each even position i of the given string s contains an uppercase letter — the type of the door that leads from room i / 2 to room i / 2 + 1.
Output
Print the only integer — the minimum number of keys that Vitaly needs to buy to surely get from room one to room n.
Examples
Input
3
aAbB
Output
0
Input
4
aBaCaB
Output
3
Input
5
xYyXzZaZ
Output
2 | instruction | 0 | 105,660 | 9 | 211,320 |
Tags: greedy, hashing, strings
Correct Solution:
```
# coding=utf-8
if __name__ == '__main__':
n = int(input())
line = str(input())
cook = {'a': 0, 'b': 0, 'c': 0, 'd': 0, 'e': 0, 'f': 0, 'g': 0, 'h': 0, 'i': 0, 'j': 0, 'k': 0, 'l': 0, 'm': 0,
'n': 0, 'o': 0, 'p': 0, 'q': 0, 'r': 0, 's': 0, 't': 0, 'u': 0, 'v': 0, 'w': 0, 'x': 0, 'y': 0, 'z': 0}
tar = 0
for i in range(n - 1):
cook[line[2 * i]] += 1
if cook[line[2 * i + 1].lower()] > 0:
cook[line[2 * i + 1].lower()] -= 1
else:
tar += 1
print(tar)
``` | output | 1 | 105,660 | 9 | 211,321 |
Provide tags and a correct Python 3 solution for this coding contest problem.
After a hard day Vitaly got very hungry and he wants to eat his favorite potato pie. But it's not that simple. Vitaly is in the first room of the house with n room located in a line and numbered starting from one from left to right. You can go from the first room to the second room, from the second room to the third room and so on — you can go from the (n - 1)-th room to the n-th room. Thus, you can go to room x only from room x - 1.
The potato pie is located in the n-th room and Vitaly needs to go there.
Each pair of consecutive rooms has a door between them. In order to go to room x from room x - 1, you need to open the door between the rooms with the corresponding key.
In total the house has several types of doors (represented by uppercase Latin letters) and several types of keys (represented by lowercase Latin letters). The key of type t can open the door of type T if and only if t and T are the same letter, written in different cases. For example, key f can open door F.
Each of the first n - 1 rooms contains exactly one key of some type that Vitaly can use to get to next rooms. Once the door is open with some key, Vitaly won't get the key from the keyhole but he will immediately run into the next room. In other words, each key can open no more than one door.
Vitaly realizes that he may end up in some room without the key that opens the door to the next room. Before the start his run for the potato pie Vitaly can buy any number of keys of any type that is guaranteed to get to room n.
Given the plan of the house, Vitaly wants to know what is the minimum number of keys he needs to buy to surely get to the room n, which has a delicious potato pie. Write a program that will help Vitaly find out this number.
Input
The first line of the input contains a positive integer n (2 ≤ n ≤ 105) — the number of rooms in the house.
The second line of the input contains string s of length 2·n - 2. Let's number the elements of the string from left to right, starting from one.
The odd positions in the given string s contain lowercase Latin letters — the types of the keys that lie in the corresponding rooms. Thus, each odd position i of the given string s contains a lowercase Latin letter — the type of the key that lies in room number (i + 1) / 2.
The even positions in the given string contain uppercase Latin letters — the types of doors between the rooms. Thus, each even position i of the given string s contains an uppercase letter — the type of the door that leads from room i / 2 to room i / 2 + 1.
Output
Print the only integer — the minimum number of keys that Vitaly needs to buy to surely get from room one to room n.
Examples
Input
3
aAbB
Output
0
Input
4
aBaCaB
Output
3
Input
5
xYyXzZaZ
Output
2 | instruction | 0 | 105,661 | 9 | 211,322 |
Tags: greedy, hashing, strings
Correct Solution:
```
from collections import Counter
n = int(input())
s = input()
keys = Counter()
buy = 0
for i in range(0, 2*n-2, 2):
keys[s[i]] += 1
room = s[i+1].lower()
if room not in keys or not keys[room]:
buy += 1
else:
keys[room] -= 1
print(buy)
``` | output | 1 | 105,661 | 9 | 211,323 |
Provide tags and a correct Python 3 solution for this coding contest problem.
After a hard day Vitaly got very hungry and he wants to eat his favorite potato pie. But it's not that simple. Vitaly is in the first room of the house with n room located in a line and numbered starting from one from left to right. You can go from the first room to the second room, from the second room to the third room and so on — you can go from the (n - 1)-th room to the n-th room. Thus, you can go to room x only from room x - 1.
The potato pie is located in the n-th room and Vitaly needs to go there.
Each pair of consecutive rooms has a door between them. In order to go to room x from room x - 1, you need to open the door between the rooms with the corresponding key.
In total the house has several types of doors (represented by uppercase Latin letters) and several types of keys (represented by lowercase Latin letters). The key of type t can open the door of type T if and only if t and T are the same letter, written in different cases. For example, key f can open door F.
Each of the first n - 1 rooms contains exactly one key of some type that Vitaly can use to get to next rooms. Once the door is open with some key, Vitaly won't get the key from the keyhole but he will immediately run into the next room. In other words, each key can open no more than one door.
Vitaly realizes that he may end up in some room without the key that opens the door to the next room. Before the start his run for the potato pie Vitaly can buy any number of keys of any type that is guaranteed to get to room n.
Given the plan of the house, Vitaly wants to know what is the minimum number of keys he needs to buy to surely get to the room n, which has a delicious potato pie. Write a program that will help Vitaly find out this number.
Input
The first line of the input contains a positive integer n (2 ≤ n ≤ 105) — the number of rooms in the house.
The second line of the input contains string s of length 2·n - 2. Let's number the elements of the string from left to right, starting from one.
The odd positions in the given string s contain lowercase Latin letters — the types of the keys that lie in the corresponding rooms. Thus, each odd position i of the given string s contains a lowercase Latin letter — the type of the key that lies in room number (i + 1) / 2.
The even positions in the given string contain uppercase Latin letters — the types of doors between the rooms. Thus, each even position i of the given string s contains an uppercase letter — the type of the door that leads from room i / 2 to room i / 2 + 1.
Output
Print the only integer — the minimum number of keys that Vitaly needs to buy to surely get from room one to room n.
Examples
Input
3
aAbB
Output
0
Input
4
aBaCaB
Output
3
Input
5
xYyXzZaZ
Output
2 | instruction | 0 | 105,662 | 9 | 211,324 |
Tags: greedy, hashing, strings
Correct Solution:
```
from collections import defaultdict
n = int(input())
inp = input()
keys = defaultdict(lambda: 0)
res = 0
for i in range(0, 2*(n-1), 2):
keys[inp[i]] += 1
if keys[inp[i+1].lower()] > 0:
keys[inp[i+1].lower()] -= 1
else:
res += 1
print(res)
``` | output | 1 | 105,662 | 9 | 211,325 |
Provide tags and a correct Python 3 solution for this coding contest problem.
After a hard day Vitaly got very hungry and he wants to eat his favorite potato pie. But it's not that simple. Vitaly is in the first room of the house with n room located in a line and numbered starting from one from left to right. You can go from the first room to the second room, from the second room to the third room and so on — you can go from the (n - 1)-th room to the n-th room. Thus, you can go to room x only from room x - 1.
The potato pie is located in the n-th room and Vitaly needs to go there.
Each pair of consecutive rooms has a door between them. In order to go to room x from room x - 1, you need to open the door between the rooms with the corresponding key.
In total the house has several types of doors (represented by uppercase Latin letters) and several types of keys (represented by lowercase Latin letters). The key of type t can open the door of type T if and only if t and T are the same letter, written in different cases. For example, key f can open door F.
Each of the first n - 1 rooms contains exactly one key of some type that Vitaly can use to get to next rooms. Once the door is open with some key, Vitaly won't get the key from the keyhole but he will immediately run into the next room. In other words, each key can open no more than one door.
Vitaly realizes that he may end up in some room without the key that opens the door to the next room. Before the start his run for the potato pie Vitaly can buy any number of keys of any type that is guaranteed to get to room n.
Given the plan of the house, Vitaly wants to know what is the minimum number of keys he needs to buy to surely get to the room n, which has a delicious potato pie. Write a program that will help Vitaly find out this number.
Input
The first line of the input contains a positive integer n (2 ≤ n ≤ 105) — the number of rooms in the house.
The second line of the input contains string s of length 2·n - 2. Let's number the elements of the string from left to right, starting from one.
The odd positions in the given string s contain lowercase Latin letters — the types of the keys that lie in the corresponding rooms. Thus, each odd position i of the given string s contains a lowercase Latin letter — the type of the key that lies in room number (i + 1) / 2.
The even positions in the given string contain uppercase Latin letters — the types of doors between the rooms. Thus, each even position i of the given string s contains an uppercase letter — the type of the door that leads from room i / 2 to room i / 2 + 1.
Output
Print the only integer — the minimum number of keys that Vitaly needs to buy to surely get from room one to room n.
Examples
Input
3
aAbB
Output
0
Input
4
aBaCaB
Output
3
Input
5
xYyXzZaZ
Output
2 | instruction | 0 | 105,663 | 9 | 211,326 |
Tags: greedy, hashing, strings
Correct Solution:
```
# bsdk idhar kya dekhne ko aaya hai, khud kr!!!
# import math
# from itertools import *
# import random
# import calendar
import datetime
# import webbrowser
n = int(input())
string = input()
keys = [0]*26
count = 0
for i in range(0, len(string), 2):
if string[i].upper() == string[i+1]:
continue
else:
if keys[ord(string[i+1].lower()) - 97] >= 1:
keys[ord(string[i + 1].lower()) - 97] -= 1
keys[ord(string[i]) - 97] += 1
else:
count += 1
keys[ord(string[i]) - 97] += 1
'''
if string[i+1].lower() in keys:
keys.remove(string[i+1].lower())
keys.append(string[i])
continue
else:
count += 1
keys.append(string[i])
'''
print(count)
``` | output | 1 | 105,663 | 9 | 211,327 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After a hard day Vitaly got very hungry and he wants to eat his favorite potato pie. But it's not that simple. Vitaly is in the first room of the house with n room located in a line and numbered starting from one from left to right. You can go from the first room to the second room, from the second room to the third room and so on — you can go from the (n - 1)-th room to the n-th room. Thus, you can go to room x only from room x - 1.
The potato pie is located in the n-th room and Vitaly needs to go there.
Each pair of consecutive rooms has a door between them. In order to go to room x from room x - 1, you need to open the door between the rooms with the corresponding key.
In total the house has several types of doors (represented by uppercase Latin letters) and several types of keys (represented by lowercase Latin letters). The key of type t can open the door of type T if and only if t and T are the same letter, written in different cases. For example, key f can open door F.
Each of the first n - 1 rooms contains exactly one key of some type that Vitaly can use to get to next rooms. Once the door is open with some key, Vitaly won't get the key from the keyhole but he will immediately run into the next room. In other words, each key can open no more than one door.
Vitaly realizes that he may end up in some room without the key that opens the door to the next room. Before the start his run for the potato pie Vitaly can buy any number of keys of any type that is guaranteed to get to room n.
Given the plan of the house, Vitaly wants to know what is the minimum number of keys he needs to buy to surely get to the room n, which has a delicious potato pie. Write a program that will help Vitaly find out this number.
Input
The first line of the input contains a positive integer n (2 ≤ n ≤ 105) — the number of rooms in the house.
The second line of the input contains string s of length 2·n - 2. Let's number the elements of the string from left to right, starting from one.
The odd positions in the given string s contain lowercase Latin letters — the types of the keys that lie in the corresponding rooms. Thus, each odd position i of the given string s contains a lowercase Latin letter — the type of the key that lies in room number (i + 1) / 2.
The even positions in the given string contain uppercase Latin letters — the types of doors between the rooms. Thus, each even position i of the given string s contains an uppercase letter — the type of the door that leads from room i / 2 to room i / 2 + 1.
Output
Print the only integer — the minimum number of keys that Vitaly needs to buy to surely get from room one to room n.
Examples
Input
3
aAbB
Output
0
Input
4
aBaCaB
Output
3
Input
5
xYyXzZaZ
Output
2
Submitted Solution:
```
#!/c/Python34/python
# coding: utf-8
def main():
N = int(input())
S = input()
count = 0
roomNum = 1
alpha = [0] * 26
for (i, s) in enumerate(S):
if roomNum == N:
break
if i % 2 == 0:
alpha[ord(s)-ord('a')] += 1
else:
if alpha[ord(s.lower())-ord('a')] == 0:
count += 1
else:
alpha[ord(s.lower())-ord('a')] -= 1
roomNum += 1
print(count)
if __name__ == '__main__':
main()
``` | instruction | 0 | 105,664 | 9 | 211,328 |
Yes | output | 1 | 105,664 | 9 | 211,329 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After a hard day Vitaly got very hungry and he wants to eat his favorite potato pie. But it's not that simple. Vitaly is in the first room of the house with n room located in a line and numbered starting from one from left to right. You can go from the first room to the second room, from the second room to the third room and so on — you can go from the (n - 1)-th room to the n-th room. Thus, you can go to room x only from room x - 1.
The potato pie is located in the n-th room and Vitaly needs to go there.
Each pair of consecutive rooms has a door between them. In order to go to room x from room x - 1, you need to open the door between the rooms with the corresponding key.
In total the house has several types of doors (represented by uppercase Latin letters) and several types of keys (represented by lowercase Latin letters). The key of type t can open the door of type T if and only if t and T are the same letter, written in different cases. For example, key f can open door F.
Each of the first n - 1 rooms contains exactly one key of some type that Vitaly can use to get to next rooms. Once the door is open with some key, Vitaly won't get the key from the keyhole but he will immediately run into the next room. In other words, each key can open no more than one door.
Vitaly realizes that he may end up in some room without the key that opens the door to the next room. Before the start his run for the potato pie Vitaly can buy any number of keys of any type that is guaranteed to get to room n.
Given the plan of the house, Vitaly wants to know what is the minimum number of keys he needs to buy to surely get to the room n, which has a delicious potato pie. Write a program that will help Vitaly find out this number.
Input
The first line of the input contains a positive integer n (2 ≤ n ≤ 105) — the number of rooms in the house.
The second line of the input contains string s of length 2·n - 2. Let's number the elements of the string from left to right, starting from one.
The odd positions in the given string s contain lowercase Latin letters — the types of the keys that lie in the corresponding rooms. Thus, each odd position i of the given string s contains a lowercase Latin letter — the type of the key that lies in room number (i + 1) / 2.
The even positions in the given string contain uppercase Latin letters — the types of doors between the rooms. Thus, each even position i of the given string s contains an uppercase letter — the type of the door that leads from room i / 2 to room i / 2 + 1.
Output
Print the only integer — the minimum number of keys that Vitaly needs to buy to surely get from room one to room n.
Examples
Input
3
aAbB
Output
0
Input
4
aBaCaB
Output
3
Input
5
xYyXzZaZ
Output
2
Submitted Solution:
```
n = int(input())
s = input()
d = {}
res = 0
for x in s:
if x.islower():
d[x] = d.get(x, 0) + 1
else:
if d.get(x.lower(), 0) > 0:
d[x.lower()] -= 1
else:
res += 1
print(res)
``` | instruction | 0 | 105,665 | 9 | 211,330 |
Yes | output | 1 | 105,665 | 9 | 211,331 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After a hard day Vitaly got very hungry and he wants to eat his favorite potato pie. But it's not that simple. Vitaly is in the first room of the house with n room located in a line and numbered starting from one from left to right. You can go from the first room to the second room, from the second room to the third room and so on — you can go from the (n - 1)-th room to the n-th room. Thus, you can go to room x only from room x - 1.
The potato pie is located in the n-th room and Vitaly needs to go there.
Each pair of consecutive rooms has a door between them. In order to go to room x from room x - 1, you need to open the door between the rooms with the corresponding key.
In total the house has several types of doors (represented by uppercase Latin letters) and several types of keys (represented by lowercase Latin letters). The key of type t can open the door of type T if and only if t and T are the same letter, written in different cases. For example, key f can open door F.
Each of the first n - 1 rooms contains exactly one key of some type that Vitaly can use to get to next rooms. Once the door is open with some key, Vitaly won't get the key from the keyhole but he will immediately run into the next room. In other words, each key can open no more than one door.
Vitaly realizes that he may end up in some room without the key that opens the door to the next room. Before the start his run for the potato pie Vitaly can buy any number of keys of any type that is guaranteed to get to room n.
Given the plan of the house, Vitaly wants to know what is the minimum number of keys he needs to buy to surely get to the room n, which has a delicious potato pie. Write a program that will help Vitaly find out this number.
Input
The first line of the input contains a positive integer n (2 ≤ n ≤ 105) — the number of rooms in the house.
The second line of the input contains string s of length 2·n - 2. Let's number the elements of the string from left to right, starting from one.
The odd positions in the given string s contain lowercase Latin letters — the types of the keys that lie in the corresponding rooms. Thus, each odd position i of the given string s contains a lowercase Latin letter — the type of the key that lies in room number (i + 1) / 2.
The even positions in the given string contain uppercase Latin letters — the types of doors between the rooms. Thus, each even position i of the given string s contains an uppercase letter — the type of the door that leads from room i / 2 to room i / 2 + 1.
Output
Print the only integer — the minimum number of keys that Vitaly needs to buy to surely get from room one to room n.
Examples
Input
3
aAbB
Output
0
Input
4
aBaCaB
Output
3
Input
5
xYyXzZaZ
Output
2
Submitted Solution:
```
n, s = int(input()), input()
a = [0] * 26
ans = 0
for i in range(len(s)):
if i & 1:
if a[ord(s[i]) - ord('A')] == 0:
a[ord(s[i]) - ord('A')] += 1
ans += 1
a[ord(s[i]) - ord('A')] -= 1
else:
a[ord(s[i]) - ord('a')] += 1
print(ans)
``` | instruction | 0 | 105,666 | 9 | 211,332 |
Yes | output | 1 | 105,666 | 9 | 211,333 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After a hard day Vitaly got very hungry and he wants to eat his favorite potato pie. But it's not that simple. Vitaly is in the first room of the house with n room located in a line and numbered starting from one from left to right. You can go from the first room to the second room, from the second room to the third room and so on — you can go from the (n - 1)-th room to the n-th room. Thus, you can go to room x only from room x - 1.
The potato pie is located in the n-th room and Vitaly needs to go there.
Each pair of consecutive rooms has a door between them. In order to go to room x from room x - 1, you need to open the door between the rooms with the corresponding key.
In total the house has several types of doors (represented by uppercase Latin letters) and several types of keys (represented by lowercase Latin letters). The key of type t can open the door of type T if and only if t and T are the same letter, written in different cases. For example, key f can open door F.
Each of the first n - 1 rooms contains exactly one key of some type that Vitaly can use to get to next rooms. Once the door is open with some key, Vitaly won't get the key from the keyhole but he will immediately run into the next room. In other words, each key can open no more than one door.
Vitaly realizes that he may end up in some room without the key that opens the door to the next room. Before the start his run for the potato pie Vitaly can buy any number of keys of any type that is guaranteed to get to room n.
Given the plan of the house, Vitaly wants to know what is the minimum number of keys he needs to buy to surely get to the room n, which has a delicious potato pie. Write a program that will help Vitaly find out this number.
Input
The first line of the input contains a positive integer n (2 ≤ n ≤ 105) — the number of rooms in the house.
The second line of the input contains string s of length 2·n - 2. Let's number the elements of the string from left to right, starting from one.
The odd positions in the given string s contain lowercase Latin letters — the types of the keys that lie in the corresponding rooms. Thus, each odd position i of the given string s contains a lowercase Latin letter — the type of the key that lies in room number (i + 1) / 2.
The even positions in the given string contain uppercase Latin letters — the types of doors between the rooms. Thus, each even position i of the given string s contains an uppercase letter — the type of the door that leads from room i / 2 to room i / 2 + 1.
Output
Print the only integer — the minimum number of keys that Vitaly needs to buy to surely get from room one to room n.
Examples
Input
3
aAbB
Output
0
Input
4
aBaCaB
Output
3
Input
5
xYyXzZaZ
Output
2
Submitted Solution:
```
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,copy,functools
import random
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(): return [list(map(int, l.split())) for l in sys.stdin.readlines()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def pe(s): return print(str(s), file=sys.stderr)
def main():
n = I()
s = S()
r = 0
d = collections.defaultdict(int)
for i in range(n-1):
t = s[i*2]
u = chr(ord(s[i*2+1]) - ord('A') + ord('a'))
d[t] += 1
if d[u] > 0:
d[u] -= 1
else:
r += 1
return r
print(main())
``` | instruction | 0 | 105,667 | 9 | 211,334 |
Yes | output | 1 | 105,667 | 9 | 211,335 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After a hard day Vitaly got very hungry and he wants to eat his favorite potato pie. But it's not that simple. Vitaly is in the first room of the house with n room located in a line and numbered starting from one from left to right. You can go from the first room to the second room, from the second room to the third room and so on — you can go from the (n - 1)-th room to the n-th room. Thus, you can go to room x only from room x - 1.
The potato pie is located in the n-th room and Vitaly needs to go there.
Each pair of consecutive rooms has a door between them. In order to go to room x from room x - 1, you need to open the door between the rooms with the corresponding key.
In total the house has several types of doors (represented by uppercase Latin letters) and several types of keys (represented by lowercase Latin letters). The key of type t can open the door of type T if and only if t and T are the same letter, written in different cases. For example, key f can open door F.
Each of the first n - 1 rooms contains exactly one key of some type that Vitaly can use to get to next rooms. Once the door is open with some key, Vitaly won't get the key from the keyhole but he will immediately run into the next room. In other words, each key can open no more than one door.
Vitaly realizes that he may end up in some room without the key that opens the door to the next room. Before the start his run for the potato pie Vitaly can buy any number of keys of any type that is guaranteed to get to room n.
Given the plan of the house, Vitaly wants to know what is the minimum number of keys he needs to buy to surely get to the room n, which has a delicious potato pie. Write a program that will help Vitaly find out this number.
Input
The first line of the input contains a positive integer n (2 ≤ n ≤ 105) — the number of rooms in the house.
The second line of the input contains string s of length 2·n - 2. Let's number the elements of the string from left to right, starting from one.
The odd positions in the given string s contain lowercase Latin letters — the types of the keys that lie in the corresponding rooms. Thus, each odd position i of the given string s contains a lowercase Latin letter — the type of the key that lies in room number (i + 1) / 2.
The even positions in the given string contain uppercase Latin letters — the types of doors between the rooms. Thus, each even position i of the given string s contains an uppercase letter — the type of the door that leads from room i / 2 to room i / 2 + 1.
Output
Print the only integer — the minimum number of keys that Vitaly needs to buy to surely get from room one to room n.
Examples
Input
3
aAbB
Output
0
Input
4
aBaCaB
Output
3
Input
5
xYyXzZaZ
Output
2
Submitted Solution:
```
n=int(input("enter no of rooms\n"))
string=input("enter string\n")
listkeys=[0]*26
count=0
q=2*n-2
#ans=ord(string[0])
#print(ans)
for i in range(0,q):
if(i%2==0):
#print(string[0])
k=ord(string[i])
#print(k)
k2=k-97
listkeys[k2]=listkeys[k2]+1
else :
k3=ord(string[i])
k4=k3+32
#print(k4-97)
if(listkeys[k4-97]>=1):
listkeys[k4-97]=listkeys[k4-97]-1
else :
count=count+1
print(count)
``` | instruction | 0 | 105,668 | 9 | 211,336 |
No | output | 1 | 105,668 | 9 | 211,337 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After a hard day Vitaly got very hungry and he wants to eat his favorite potato pie. But it's not that simple. Vitaly is in the first room of the house with n room located in a line and numbered starting from one from left to right. You can go from the first room to the second room, from the second room to the third room and so on — you can go from the (n - 1)-th room to the n-th room. Thus, you can go to room x only from room x - 1.
The potato pie is located in the n-th room and Vitaly needs to go there.
Each pair of consecutive rooms has a door between them. In order to go to room x from room x - 1, you need to open the door between the rooms with the corresponding key.
In total the house has several types of doors (represented by uppercase Latin letters) and several types of keys (represented by lowercase Latin letters). The key of type t can open the door of type T if and only if t and T are the same letter, written in different cases. For example, key f can open door F.
Each of the first n - 1 rooms contains exactly one key of some type that Vitaly can use to get to next rooms. Once the door is open with some key, Vitaly won't get the key from the keyhole but he will immediately run into the next room. In other words, each key can open no more than one door.
Vitaly realizes that he may end up in some room without the key that opens the door to the next room. Before the start his run for the potato pie Vitaly can buy any number of keys of any type that is guaranteed to get to room n.
Given the plan of the house, Vitaly wants to know what is the minimum number of keys he needs to buy to surely get to the room n, which has a delicious potato pie. Write a program that will help Vitaly find out this number.
Input
The first line of the input contains a positive integer n (2 ≤ n ≤ 105) — the number of rooms in the house.
The second line of the input contains string s of length 2·n - 2. Let's number the elements of the string from left to right, starting from one.
The odd positions in the given string s contain lowercase Latin letters — the types of the keys that lie in the corresponding rooms. Thus, each odd position i of the given string s contains a lowercase Latin letter — the type of the key that lies in room number (i + 1) / 2.
The even positions in the given string contain uppercase Latin letters — the types of doors between the rooms. Thus, each even position i of the given string s contains an uppercase letter — the type of the door that leads from room i / 2 to room i / 2 + 1.
Output
Print the only integer — the minimum number of keys that Vitaly needs to buy to surely get from room one to room n.
Examples
Input
3
aAbB
Output
0
Input
4
aBaCaB
Output
3
Input
5
xYyXzZaZ
Output
2
Submitted Solution:
```
n = int(input())
seq = input()
ans = 0
seen = set()
for e in seq:
if e.islower():
seen.add(e)
else:
if e.lower() not in seen:
ans += 1
else:
seen.discard(e.lower())
print(ans)
``` | instruction | 0 | 105,669 | 9 | 211,338 |
No | output | 1 | 105,669 | 9 | 211,339 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After a hard day Vitaly got very hungry and he wants to eat his favorite potato pie. But it's not that simple. Vitaly is in the first room of the house with n room located in a line and numbered starting from one from left to right. You can go from the first room to the second room, from the second room to the third room and so on — you can go from the (n - 1)-th room to the n-th room. Thus, you can go to room x only from room x - 1.
The potato pie is located in the n-th room and Vitaly needs to go there.
Each pair of consecutive rooms has a door between them. In order to go to room x from room x - 1, you need to open the door between the rooms with the corresponding key.
In total the house has several types of doors (represented by uppercase Latin letters) and several types of keys (represented by lowercase Latin letters). The key of type t can open the door of type T if and only if t and T are the same letter, written in different cases. For example, key f can open door F.
Each of the first n - 1 rooms contains exactly one key of some type that Vitaly can use to get to next rooms. Once the door is open with some key, Vitaly won't get the key from the keyhole but he will immediately run into the next room. In other words, each key can open no more than one door.
Vitaly realizes that he may end up in some room without the key that opens the door to the next room. Before the start his run for the potato pie Vitaly can buy any number of keys of any type that is guaranteed to get to room n.
Given the plan of the house, Vitaly wants to know what is the minimum number of keys he needs to buy to surely get to the room n, which has a delicious potato pie. Write a program that will help Vitaly find out this number.
Input
The first line of the input contains a positive integer n (2 ≤ n ≤ 105) — the number of rooms in the house.
The second line of the input contains string s of length 2·n - 2. Let's number the elements of the string from left to right, starting from one.
The odd positions in the given string s contain lowercase Latin letters — the types of the keys that lie in the corresponding rooms. Thus, each odd position i of the given string s contains a lowercase Latin letter — the type of the key that lies in room number (i + 1) / 2.
The even positions in the given string contain uppercase Latin letters — the types of doors between the rooms. Thus, each even position i of the given string s contains an uppercase letter — the type of the door that leads from room i / 2 to room i / 2 + 1.
Output
Print the only integer — the minimum number of keys that Vitaly needs to buy to surely get from room one to room n.
Examples
Input
3
aAbB
Output
0
Input
4
aBaCaB
Output
3
Input
5
xYyXzZaZ
Output
2
Submitted Solution:
```
input()
t = input()
keys = t[0::2]
rooms = t[1::2].lower()
currentKeys = set()
count = 0
for k,r in zip(keys, rooms):
currentKeys.add(k)
if r in currentKeys: currentKeys.remove(r)
else:
count += 1
print (count)
``` | instruction | 0 | 105,670 | 9 | 211,340 |
No | output | 1 | 105,670 | 9 | 211,341 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After a hard day Vitaly got very hungry and he wants to eat his favorite potato pie. But it's not that simple. Vitaly is in the first room of the house with n room located in a line and numbered starting from one from left to right. You can go from the first room to the second room, from the second room to the third room and so on — you can go from the (n - 1)-th room to the n-th room. Thus, you can go to room x only from room x - 1.
The potato pie is located in the n-th room and Vitaly needs to go there.
Each pair of consecutive rooms has a door between them. In order to go to room x from room x - 1, you need to open the door between the rooms with the corresponding key.
In total the house has several types of doors (represented by uppercase Latin letters) and several types of keys (represented by lowercase Latin letters). The key of type t can open the door of type T if and only if t and T are the same letter, written in different cases. For example, key f can open door F.
Each of the first n - 1 rooms contains exactly one key of some type that Vitaly can use to get to next rooms. Once the door is open with some key, Vitaly won't get the key from the keyhole but he will immediately run into the next room. In other words, each key can open no more than one door.
Vitaly realizes that he may end up in some room without the key that opens the door to the next room. Before the start his run for the potato pie Vitaly can buy any number of keys of any type that is guaranteed to get to room n.
Given the plan of the house, Vitaly wants to know what is the minimum number of keys he needs to buy to surely get to the room n, which has a delicious potato pie. Write a program that will help Vitaly find out this number.
Input
The first line of the input contains a positive integer n (2 ≤ n ≤ 105) — the number of rooms in the house.
The second line of the input contains string s of length 2·n - 2. Let's number the elements of the string from left to right, starting from one.
The odd positions in the given string s contain lowercase Latin letters — the types of the keys that lie in the corresponding rooms. Thus, each odd position i of the given string s contains a lowercase Latin letter — the type of the key that lies in room number (i + 1) / 2.
The even positions in the given string contain uppercase Latin letters — the types of doors between the rooms. Thus, each even position i of the given string s contains an uppercase letter — the type of the door that leads from room i / 2 to room i / 2 + 1.
Output
Print the only integer — the minimum number of keys that Vitaly needs to buy to surely get from room one to room n.
Examples
Input
3
aAbB
Output
0
Input
4
aBaCaB
Output
3
Input
5
xYyXzZaZ
Output
2
Submitted Solution:
```
n=int(input().strip())
l=input().strip()
result=0
d={}
for i in range(0,(n-1)*2,2):
if(l[i]==l[i+1].lower()):
continue
elif(d.get(l[i+1].lower(),0)):
d[l[i+1].lower()]-=1
else:
result+=1
d[l[i]]=1
print(result)
``` | instruction | 0 | 105,671 | 9 | 211,342 |
No | output | 1 | 105,671 | 9 | 211,343 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is the harder version of the problem. In this version, 1 ≤ n ≤ 10^6 and 0 ≤ a_i ≤ 10^6. You can hack this problem if you locked it. But you can hack the previous problem only if you locked both problems
Christmas is coming, and our protagonist, Bob, is preparing a spectacular present for his long-time best friend Alice. This year, he decides to prepare n boxes of chocolate, numbered from 1 to n. Initially, the i-th box contains a_i chocolate pieces.
Since Bob is a typical nice guy, he will not send Alice n empty boxes. In other words, at least one of a_1, a_2, …, a_n is positive. Since Alice dislikes coprime sets, she will be happy only if there exists some integer k > 1 such that the number of pieces in each box is divisible by k. Note that Alice won't mind if there exists some empty boxes.
Charlie, Alice's boyfriend, also is Bob's second best friend, so he decides to help Bob by rearranging the chocolate pieces. In one second, Charlie can pick up a piece in box i and put it into either box i-1 or box i+1 (if such boxes exist). Of course, he wants to help his friend as quickly as possible. Therefore, he asks you to calculate the minimum number of seconds he would need to make Alice happy.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^6) — the number of chocolate boxes.
The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 10^6) — the number of chocolate pieces in the i-th box.
It is guaranteed that at least one of a_1, a_2, …, a_n is positive.
Output
If there is no way for Charlie to make Alice happy, print -1.
Otherwise, print a single integer x — the minimum number of seconds for Charlie to help Bob make Alice happy.
Examples
Input
3
4 8 5
Output
9
Input
5
3 10 2 1 5
Output
2
Input
4
0 5 15 10
Output
0
Input
1
1
Output
-1
Note
In the first example, Charlie can move all chocolate pieces to the second box. Each box will be divisible by 17.
In the second example, Charlie can move a piece from box 2 to box 3 and a piece from box 4 to box 5. Each box will be divisible by 3.
In the third example, each box is already divisible by 5.
In the fourth example, since Charlie has no available move, he cannot help Bob make Alice happy. | instruction | 0 | 107,947 | 9 | 215,894 |
Tags: constructive algorithms, greedy, math, number theory, ternary search, two pointers
Correct Solution:
```
import sys
# inf = open('input.txt', 'r')
# input = inf.readline
input = sys.stdin.readline
n = int(input())
a = list(map(int, input().split()))
def primeDivisors(num):
sqrtNum = int(num ** 0.5) + 1
primes = []
if not num & 1:
primes.append(2)
while not num & 1:
num >>= 1
f = 3
while f < sqrtNum and num > 1:
if num % f == 0:
primes.append(f)
while num % f == 0:
num //= f
f += 2
if num > 1:
primes.append(num)
return primes
def minMoves(n, a):
num = sum(a)
if num == 1:
return None
ans = float('inf')
for p in primeDivisors(num):
ansP = 0
leftSum = 0
for i in range(n):
leftSum += a[i]
leftSum %= p
ansP += min(leftSum, p - leftSum)
ans = min(ans, ansP)
return ans
ans = minMoves(n, a)
if ans is None:
print(-1)
else:
print(ans)
# inf.close()
``` | output | 1 | 107,947 | 9 | 215,895 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is the harder version of the problem. In this version, 1 ≤ n ≤ 10^6 and 0 ≤ a_i ≤ 10^6. You can hack this problem if you locked it. But you can hack the previous problem only if you locked both problems
Christmas is coming, and our protagonist, Bob, is preparing a spectacular present for his long-time best friend Alice. This year, he decides to prepare n boxes of chocolate, numbered from 1 to n. Initially, the i-th box contains a_i chocolate pieces.
Since Bob is a typical nice guy, he will not send Alice n empty boxes. In other words, at least one of a_1, a_2, …, a_n is positive. Since Alice dislikes coprime sets, she will be happy only if there exists some integer k > 1 such that the number of pieces in each box is divisible by k. Note that Alice won't mind if there exists some empty boxes.
Charlie, Alice's boyfriend, also is Bob's second best friend, so he decides to help Bob by rearranging the chocolate pieces. In one second, Charlie can pick up a piece in box i and put it into either box i-1 or box i+1 (if such boxes exist). Of course, he wants to help his friend as quickly as possible. Therefore, he asks you to calculate the minimum number of seconds he would need to make Alice happy.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^6) — the number of chocolate boxes.
The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 10^6) — the number of chocolate pieces in the i-th box.
It is guaranteed that at least one of a_1, a_2, …, a_n is positive.
Output
If there is no way for Charlie to make Alice happy, print -1.
Otherwise, print a single integer x — the minimum number of seconds for Charlie to help Bob make Alice happy.
Examples
Input
3
4 8 5
Output
9
Input
5
3 10 2 1 5
Output
2
Input
4
0 5 15 10
Output
0
Input
1
1
Output
-1
Note
In the first example, Charlie can move all chocolate pieces to the second box. Each box will be divisible by 17.
In the second example, Charlie can move a piece from box 2 to box 3 and a piece from box 4 to box 5. Each box will be divisible by 3.
In the third example, each box is already divisible by 5.
In the fourth example, since Charlie has no available move, he cannot help Bob make Alice happy. | instruction | 0 | 107,948 | 9 | 215,896 |
Tags: constructive algorithms, greedy, math, number theory, ternary search, two pointers
Correct Solution:
```
n = int(input())
l = list(map(int,input().split()))
def jebaj(d, k):
res = 0
pyk = d[0]%k
for i in range(n - 2):
res += min(pyk, k - pyk)
pyk = (pyk + d[i+1])%k
res += min(pyk, k - pyk)
return res
s = sum(l)
out = 10000000000000000000000000
if s <= 1:
print(-1)
else:
i = 2
ss = s
primes = []
while ss > 1 and i * i <= s:
if ss%i == 0:
ss //= i
if len(primes) == 0 or i != primes[-1]:
primes.append(i)
else:
i += 1
if ss * ss > s:
primes.append(ss)
for i in primes:
out = min(out, jebaj(l, i))
print(out)
``` | output | 1 | 107,948 | 9 | 215,897 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is the harder version of the problem. In this version, 1 ≤ n ≤ 10^6 and 0 ≤ a_i ≤ 10^6. You can hack this problem if you locked it. But you can hack the previous problem only if you locked both problems
Christmas is coming, and our protagonist, Bob, is preparing a spectacular present for his long-time best friend Alice. This year, he decides to prepare n boxes of chocolate, numbered from 1 to n. Initially, the i-th box contains a_i chocolate pieces.
Since Bob is a typical nice guy, he will not send Alice n empty boxes. In other words, at least one of a_1, a_2, …, a_n is positive. Since Alice dislikes coprime sets, she will be happy only if there exists some integer k > 1 such that the number of pieces in each box is divisible by k. Note that Alice won't mind if there exists some empty boxes.
Charlie, Alice's boyfriend, also is Bob's second best friend, so he decides to help Bob by rearranging the chocolate pieces. In one second, Charlie can pick up a piece in box i and put it into either box i-1 or box i+1 (if such boxes exist). Of course, he wants to help his friend as quickly as possible. Therefore, he asks you to calculate the minimum number of seconds he would need to make Alice happy.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^6) — the number of chocolate boxes.
The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 10^6) — the number of chocolate pieces in the i-th box.
It is guaranteed that at least one of a_1, a_2, …, a_n is positive.
Output
If there is no way for Charlie to make Alice happy, print -1.
Otherwise, print a single integer x — the minimum number of seconds for Charlie to help Bob make Alice happy.
Examples
Input
3
4 8 5
Output
9
Input
5
3 10 2 1 5
Output
2
Input
4
0 5 15 10
Output
0
Input
1
1
Output
-1
Note
In the first example, Charlie can move all chocolate pieces to the second box. Each box will be divisible by 17.
In the second example, Charlie can move a piece from box 2 to box 3 and a piece from box 4 to box 5. Each box will be divisible by 3.
In the third example, each box is already divisible by 5.
In the fourth example, since Charlie has no available move, he cannot help Bob make Alice happy. | instruction | 0 | 107,949 | 9 | 215,898 |
Tags: constructive algorithms, greedy, math, number theory, ternary search, two pointers
Correct Solution:
```
import math
arr = [0] * 1000100
n = 0
# Calculate amount of move for prime number x
def gogo(x):
global n
global arr
cv = 0
ans = 0
for i in range(n):
cv = (cv + arr[i]) % x
ans += min(cv, x - cv)
# print(x, i, arr[i], cv, ans)
return ans
def main():
global n
global arr
n = int(input())
csum = 0
arr = list(map(int, input().split()))
csum = sum(arr)
# v stores the prime
v = []
for i in range(2, math.ceil(math.sqrt(csum)) + 1):
if csum % i == 0:
v.append(i)
while csum % i == 0:
csum //= i
if csum > 1:
v.append(csum)
# print(v)
ans = 3e18
for f in v:
# Find minimum amount of moves
ans = min(ans, gogo(f))
# print(f, ans)
if ans > 2e18:
print(-1)
else:
print(ans)
main()
``` | output | 1 | 107,949 | 9 | 215,899 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is the harder version of the problem. In this version, 1 ≤ n ≤ 10^6 and 0 ≤ a_i ≤ 10^6. You can hack this problem if you locked it. But you can hack the previous problem only if you locked both problems
Christmas is coming, and our protagonist, Bob, is preparing a spectacular present for his long-time best friend Alice. This year, he decides to prepare n boxes of chocolate, numbered from 1 to n. Initially, the i-th box contains a_i chocolate pieces.
Since Bob is a typical nice guy, he will not send Alice n empty boxes. In other words, at least one of a_1, a_2, …, a_n is positive. Since Alice dislikes coprime sets, she will be happy only if there exists some integer k > 1 such that the number of pieces in each box is divisible by k. Note that Alice won't mind if there exists some empty boxes.
Charlie, Alice's boyfriend, also is Bob's second best friend, so he decides to help Bob by rearranging the chocolate pieces. In one second, Charlie can pick up a piece in box i and put it into either box i-1 or box i+1 (if such boxes exist). Of course, he wants to help his friend as quickly as possible. Therefore, he asks you to calculate the minimum number of seconds he would need to make Alice happy.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^6) — the number of chocolate boxes.
The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 10^6) — the number of chocolate pieces in the i-th box.
It is guaranteed that at least one of a_1, a_2, …, a_n is positive.
Output
If there is no way for Charlie to make Alice happy, print -1.
Otherwise, print a single integer x — the minimum number of seconds for Charlie to help Bob make Alice happy.
Examples
Input
3
4 8 5
Output
9
Input
5
3 10 2 1 5
Output
2
Input
4
0 5 15 10
Output
0
Input
1
1
Output
-1
Note
In the first example, Charlie can move all chocolate pieces to the second box. Each box will be divisible by 17.
In the second example, Charlie can move a piece from box 2 to box 3 and a piece from box 4 to box 5. Each box will be divisible by 3.
In the third example, each box is already divisible by 5.
In the fourth example, since Charlie has no available move, he cannot help Bob make Alice happy. | instruction | 0 | 107,950 | 9 | 215,900 |
Tags: constructive algorithms, greedy, math, number theory, ternary search, two pointers
Correct Solution:
```
# kaisetsu AC
import sys
reader = (s.rstrip() for s in sys.stdin)
input = reader.__next__
def divisor(n):
ret = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
ret.append(i)
if i*i != n:
ret.append(n//i)
return ret
def divisor2(n):
i = 2
m = n
ret = []
while m > 1 and i*i <= n:
if m%i == 0:
m //= i
if len(ret) == 0 or i != ret[-1]:
ret.append(i)
else:
i += 1
if m*m > n:
ret.append(m)
return ret
def solve():
n = int(input())
a = list(map(int, input().split()))
s = sum(a)
ans = float("inf")
for k in divisor2(s):
if k == 1:
continue
tmp = 0
cs = 0
for i in range(n):
cs += a[i]
cs %= k
tmp += min(cs, k-cs)
ans = min(ans, tmp)
if ans == float("inf"):
print(-1)
else:
print(ans)
solve()
``` | output | 1 | 107,950 | 9 | 215,901 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is the harder version of the problem. In this version, 1 ≤ n ≤ 10^6 and 0 ≤ a_i ≤ 10^6. You can hack this problem if you locked it. But you can hack the previous problem only if you locked both problems
Christmas is coming, and our protagonist, Bob, is preparing a spectacular present for his long-time best friend Alice. This year, he decides to prepare n boxes of chocolate, numbered from 1 to n. Initially, the i-th box contains a_i chocolate pieces.
Since Bob is a typical nice guy, he will not send Alice n empty boxes. In other words, at least one of a_1, a_2, …, a_n is positive. Since Alice dislikes coprime sets, she will be happy only if there exists some integer k > 1 such that the number of pieces in each box is divisible by k. Note that Alice won't mind if there exists some empty boxes.
Charlie, Alice's boyfriend, also is Bob's second best friend, so he decides to help Bob by rearranging the chocolate pieces. In one second, Charlie can pick up a piece in box i and put it into either box i-1 or box i+1 (if such boxes exist). Of course, he wants to help his friend as quickly as possible. Therefore, he asks you to calculate the minimum number of seconds he would need to make Alice happy.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^6) — the number of chocolate boxes.
The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 10^6) — the number of chocolate pieces in the i-th box.
It is guaranteed that at least one of a_1, a_2, …, a_n is positive.
Output
If there is no way for Charlie to make Alice happy, print -1.
Otherwise, print a single integer x — the minimum number of seconds for Charlie to help Bob make Alice happy.
Examples
Input
3
4 8 5
Output
9
Input
5
3 10 2 1 5
Output
2
Input
4
0 5 15 10
Output
0
Input
1
1
Output
-1
Note
In the first example, Charlie can move all chocolate pieces to the second box. Each box will be divisible by 17.
In the second example, Charlie can move a piece from box 2 to box 3 and a piece from box 4 to box 5. Each box will be divisible by 3.
In the third example, each box is already divisible by 5.
In the fourth example, since Charlie has no available move, he cannot help Bob make Alice happy. | instruction | 0 | 107,951 | 9 | 215,902 |
Tags: constructive algorithms, greedy, math, number theory, ternary search, two pointers
Correct Solution:
```
import sys
import math
def alele(): return list(map(int, sys.stdin.readline().strip().split()))
def ilele(): return map(int, sys.stdin.readline().strip().split())
def input(): return sys.stdin.readline().strip()
N = int(input())
Arr = alele()
tot = sum(Arr)
a=2
b=math.ceil(tot**0.5) + 1
values = []
for i in range(a,b):
if tot % i == 0:
values.append(i)
while(tot%i==0):
tot= tot//i
if tot > 1:
values.append(tot)
res = 3e18
for i in values:
v=0;ans=0
for j in range(N):
v = (v + Arr[j]) % i
ans += min(v, i - v)
res = min(res,ans)
print(-1) if res > 1e18 else print(res)
``` | output | 1 | 107,951 | 9 | 215,903 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is the harder version of the problem. In this version, 1 ≤ n ≤ 10^6 and 0 ≤ a_i ≤ 10^6. You can hack this problem if you locked it. But you can hack the previous problem only if you locked both problems
Christmas is coming, and our protagonist, Bob, is preparing a spectacular present for his long-time best friend Alice. This year, he decides to prepare n boxes of chocolate, numbered from 1 to n. Initially, the i-th box contains a_i chocolate pieces.
Since Bob is a typical nice guy, he will not send Alice n empty boxes. In other words, at least one of a_1, a_2, …, a_n is positive. Since Alice dislikes coprime sets, she will be happy only if there exists some integer k > 1 such that the number of pieces in each box is divisible by k. Note that Alice won't mind if there exists some empty boxes.
Charlie, Alice's boyfriend, also is Bob's second best friend, so he decides to help Bob by rearranging the chocolate pieces. In one second, Charlie can pick up a piece in box i and put it into either box i-1 or box i+1 (if such boxes exist). Of course, he wants to help his friend as quickly as possible. Therefore, he asks you to calculate the minimum number of seconds he would need to make Alice happy.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^6) — the number of chocolate boxes.
The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 10^6) — the number of chocolate pieces in the i-th box.
It is guaranteed that at least one of a_1, a_2, …, a_n is positive.
Output
If there is no way for Charlie to make Alice happy, print -1.
Otherwise, print a single integer x — the minimum number of seconds for Charlie to help Bob make Alice happy.
Examples
Input
3
4 8 5
Output
9
Input
5
3 10 2 1 5
Output
2
Input
4
0 5 15 10
Output
0
Input
1
1
Output
-1
Note
In the first example, Charlie can move all chocolate pieces to the second box. Each box will be divisible by 17.
In the second example, Charlie can move a piece from box 2 to box 3 and a piece from box 4 to box 5. Each box will be divisible by 3.
In the third example, each box is already divisible by 5.
In the fourth example, since Charlie has no available move, he cannot help Bob make Alice happy.
Submitted Solution:
```
import math
arr = [0] * 1000100
n = 0
# Calculate amount of move for prime number x
def gogo(x):
global n
global arr
cv = 0
ans = 0
for i in range(n):
cv = (cv + arr[i]) % x
ans += min(cv, x - cv)
# print(x, i, arr[i], cv, ans)
return ans
def main():
global n
global arr
n = int(input())
csum = 0
arr = list(map(int, input().split()))
csum = sum(arr)
# v stores the prime
v = []
for i in range(2, math.ceil(math.sqrt(csum)) + 1):
if csum % i == 0:
v.append(i)
while csum % i == 0:
csum //= i
if csum > 1:
v.append(csum)
print(v)
ans = 3e18
for f in v:
# Find minimum amount of moves
ans = min(ans, gogo(f))
# print(f, ans)
if ans > 2e18:
print(-1)
else:
print(ans)
main()
``` | instruction | 0 | 107,952 | 9 | 215,904 |
No | output | 1 | 107,952 | 9 | 215,905 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is the harder version of the problem. In this version, 1 ≤ n ≤ 10^6 and 0 ≤ a_i ≤ 10^6. You can hack this problem if you locked it. But you can hack the previous problem only if you locked both problems
Christmas is coming, and our protagonist, Bob, is preparing a spectacular present for his long-time best friend Alice. This year, he decides to prepare n boxes of chocolate, numbered from 1 to n. Initially, the i-th box contains a_i chocolate pieces.
Since Bob is a typical nice guy, he will not send Alice n empty boxes. In other words, at least one of a_1, a_2, …, a_n is positive. Since Alice dislikes coprime sets, she will be happy only if there exists some integer k > 1 such that the number of pieces in each box is divisible by k. Note that Alice won't mind if there exists some empty boxes.
Charlie, Alice's boyfriend, also is Bob's second best friend, so he decides to help Bob by rearranging the chocolate pieces. In one second, Charlie can pick up a piece in box i and put it into either box i-1 or box i+1 (if such boxes exist). Of course, he wants to help his friend as quickly as possible. Therefore, he asks you to calculate the minimum number of seconds he would need to make Alice happy.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^6) — the number of chocolate boxes.
The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 10^6) — the number of chocolate pieces in the i-th box.
It is guaranteed that at least one of a_1, a_2, …, a_n is positive.
Output
If there is no way for Charlie to make Alice happy, print -1.
Otherwise, print a single integer x — the minimum number of seconds for Charlie to help Bob make Alice happy.
Examples
Input
3
4 8 5
Output
9
Input
5
3 10 2 1 5
Output
2
Input
4
0 5 15 10
Output
0
Input
1
1
Output
-1
Note
In the first example, Charlie can move all chocolate pieces to the second box. Each box will be divisible by 17.
In the second example, Charlie can move a piece from box 2 to box 3 and a piece from box 4 to box 5. Each box will be divisible by 3.
In the third example, each box is already divisible by 5.
In the fourth example, since Charlie has no available move, he cannot help Bob make Alice happy.
Submitted Solution:
```
n = int(input())
l = list(map(int,input().split()))
def jebaj(d, k):
res = 0
pyk = d[0]
for i in range(n - 2):
res += min(pyk%k, k - pyk%k)
pyk = (pyk + d[i+1])%k
res += min(pyk%k, k - pyk%k)
return res
s = sum(l)
out = 100000000000000000000000000
import math
if s <= 1:
print(-1)
else:
i = 2
ss = s
primes = []
while ss > 1 and i * i <= s:
if ss%i == 0:
ss //= i
if len(primes) == 0 or i != primes[-1]:
primes.append(i)
else:
i += 1
if ss * ss >= s:
primes.append(s)
for i in primes:
if i > s:
break
if s%i == 0:
out = min(out, jebaj(l, i))
print(out)
``` | instruction | 0 | 107,953 | 9 | 215,906 |
No | output | 1 | 107,953 | 9 | 215,907 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is the harder version of the problem. In this version, 1 ≤ n ≤ 10^6 and 0 ≤ a_i ≤ 10^6. You can hack this problem if you locked it. But you can hack the previous problem only if you locked both problems
Christmas is coming, and our protagonist, Bob, is preparing a spectacular present for his long-time best friend Alice. This year, he decides to prepare n boxes of chocolate, numbered from 1 to n. Initially, the i-th box contains a_i chocolate pieces.
Since Bob is a typical nice guy, he will not send Alice n empty boxes. In other words, at least one of a_1, a_2, …, a_n is positive. Since Alice dislikes coprime sets, she will be happy only if there exists some integer k > 1 such that the number of pieces in each box is divisible by k. Note that Alice won't mind if there exists some empty boxes.
Charlie, Alice's boyfriend, also is Bob's second best friend, so he decides to help Bob by rearranging the chocolate pieces. In one second, Charlie can pick up a piece in box i and put it into either box i-1 or box i+1 (if such boxes exist). Of course, he wants to help his friend as quickly as possible. Therefore, he asks you to calculate the minimum number of seconds he would need to make Alice happy.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^6) — the number of chocolate boxes.
The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 10^6) — the number of chocolate pieces in the i-th box.
It is guaranteed that at least one of a_1, a_2, …, a_n is positive.
Output
If there is no way for Charlie to make Alice happy, print -1.
Otherwise, print a single integer x — the minimum number of seconds for Charlie to help Bob make Alice happy.
Examples
Input
3
4 8 5
Output
9
Input
5
3 10 2 1 5
Output
2
Input
4
0 5 15 10
Output
0
Input
1
1
Output
-1
Note
In the first example, Charlie can move all chocolate pieces to the second box. Each box will be divisible by 17.
In the second example, Charlie can move a piece from box 2 to box 3 and a piece from box 4 to box 5. Each box will be divisible by 3.
In the third example, each box is already divisible by 5.
In the fourth example, since Charlie has no available move, he cannot help Bob make Alice happy.
Submitted Solution:
```
n = int(input())
l = list(map(int,input().split()))
def jebaj(d, k):
res = 0
for i in range(len(d) - 1):
res += (d[i + 1][1] - d[i][1])*min(d[i][0]%k, d[i + 1][0] % k)
if d[i][0]%k > d[i + 1][0]%k:
d[i][0] += d[i + 1][0]%k
d[i + 1][0] -= d[i + 1][0]%k
else:
d[i + 1][0] += d[i][0]%k
d[i][0] -= d[i][0]%k
return res
s = sum(l)
out = 100000000000
for i in list(range(2,1001)) + [s]:
dd = []
for j in range(n):
if l[j] > 0:
dd.append([l[j], j])
if s%i == 0:
out = min(out, jebaj(dd, i))
print(out)
``` | instruction | 0 | 107,954 | 9 | 215,908 |
No | output | 1 | 107,954 | 9 | 215,909 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is the harder version of the problem. In this version, 1 ≤ n ≤ 10^6 and 0 ≤ a_i ≤ 10^6. You can hack this problem if you locked it. But you can hack the previous problem only if you locked both problems
Christmas is coming, and our protagonist, Bob, is preparing a spectacular present for his long-time best friend Alice. This year, he decides to prepare n boxes of chocolate, numbered from 1 to n. Initially, the i-th box contains a_i chocolate pieces.
Since Bob is a typical nice guy, he will not send Alice n empty boxes. In other words, at least one of a_1, a_2, …, a_n is positive. Since Alice dislikes coprime sets, she will be happy only if there exists some integer k > 1 such that the number of pieces in each box is divisible by k. Note that Alice won't mind if there exists some empty boxes.
Charlie, Alice's boyfriend, also is Bob's second best friend, so he decides to help Bob by rearranging the chocolate pieces. In one second, Charlie can pick up a piece in box i and put it into either box i-1 or box i+1 (if such boxes exist). Of course, he wants to help his friend as quickly as possible. Therefore, he asks you to calculate the minimum number of seconds he would need to make Alice happy.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^6) — the number of chocolate boxes.
The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 10^6) — the number of chocolate pieces in the i-th box.
It is guaranteed that at least one of a_1, a_2, …, a_n is positive.
Output
If there is no way for Charlie to make Alice happy, print -1.
Otherwise, print a single integer x — the minimum number of seconds for Charlie to help Bob make Alice happy.
Examples
Input
3
4 8 5
Output
9
Input
5
3 10 2 1 5
Output
2
Input
4
0 5 15 10
Output
0
Input
1
1
Output
-1
Note
In the first example, Charlie can move all chocolate pieces to the second box. Each box will be divisible by 17.
In the second example, Charlie can move a piece from box 2 to box 3 and a piece from box 4 to box 5. Each box will be divisible by 3.
In the third example, each box is already divisible by 5.
In the fourth example, since Charlie has no available move, he cannot help Bob make Alice happy.
Submitted Solution:
```
n = int(input())
l = list(map(int,input().split()))
def jebaj(d, k):
res = 0
pyk = d[0]
for i in range(n - 2):
res += min(pyk, k - pyk)
pyk = (pyk + d[i+1])%k
res += min(pyk, k - pyk)
return res
s = sum(l)
out = 10000000000000000000000000
import math
if s <= 1:
print(-1)
else:
i = 2
ss = s
primes = []
while ss > 1 and i * i <= s:
if ss%i == 0:
ss //= i
if len(primes) == 0 or i != primes[-1]:
primes.append(i)
else:
i += 1
if ss * ss > s:
primes.append(ss)
for i in primes:
out = min(out, jebaj(l, i))
print(out)
``` | instruction | 0 | 107,955 | 9 | 215,910 |
No | output | 1 | 107,955 | 9 | 215,911 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Katie, Kuro and Shiro are best friends. They have known each other since kindergarten. That's why they often share everything with each other and work together on some very hard problems.
Today is Shiro's birthday. She really loves pizza so she wants to invite her friends to the pizza restaurant near her house to celebrate her birthday, including her best friends Katie and Kuro.
She has ordered a very big round pizza, in order to serve her many friends. Exactly n of Shiro's friends are here. That's why she has to divide the pizza into n + 1 slices (Shiro also needs to eat). She wants the slices to be exactly the same size and shape. If not, some of her friends will get mad and go home early, and the party will be over.
Shiro is now hungry. She wants to cut the pizza with minimum of straight cuts. A cut is a straight segment, it might have ends inside or outside the pizza. But she is too lazy to pick up the calculator.
As usual, she will ask Katie and Kuro for help. But they haven't come yet. Could you help Shiro with this problem?
Input
A single line contains one non-negative integer n (0 ≤ n ≤ 10^{18}) — the number of Shiro's friends. The circular pizza has to be sliced into n + 1 pieces.
Output
A single integer — the number of straight cuts Shiro needs.
Examples
Input
3
Output
2
Input
4
Output
5
Note
To cut the round pizza into quarters one has to make two cuts through the center with angle 90^{\circ} between them.
To cut the round pizza into five equal parts one has to make five cuts. | instruction | 0 | 108,379 | 9 | 216,758 |
Tags: math
Correct Solution:
```
def cut(n):
if n ==0: return (0)
if n%2:
return (n+1)//2
else:
return (n+1)
n = int(input())
print(cut(n))
``` | output | 1 | 108,379 | 9 | 216,759 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Katie, Kuro and Shiro are best friends. They have known each other since kindergarten. That's why they often share everything with each other and work together on some very hard problems.
Today is Shiro's birthday. She really loves pizza so she wants to invite her friends to the pizza restaurant near her house to celebrate her birthday, including her best friends Katie and Kuro.
She has ordered a very big round pizza, in order to serve her many friends. Exactly n of Shiro's friends are here. That's why she has to divide the pizza into n + 1 slices (Shiro also needs to eat). She wants the slices to be exactly the same size and shape. If not, some of her friends will get mad and go home early, and the party will be over.
Shiro is now hungry. She wants to cut the pizza with minimum of straight cuts. A cut is a straight segment, it might have ends inside or outside the pizza. But she is too lazy to pick up the calculator.
As usual, she will ask Katie and Kuro for help. But they haven't come yet. Could you help Shiro with this problem?
Input
A single line contains one non-negative integer n (0 ≤ n ≤ 10^{18}) — the number of Shiro's friends. The circular pizza has to be sliced into n + 1 pieces.
Output
A single integer — the number of straight cuts Shiro needs.
Examples
Input
3
Output
2
Input
4
Output
5
Note
To cut the round pizza into quarters one has to make two cuts through the center with angle 90^{\circ} between them.
To cut the round pizza into five equal parts one has to make five cuts. | instruction | 0 | 108,380 | 9 | 216,760 |
Tags: math
Correct Solution:
```
import os
import sys
def main():
n = int(input())
if n % 2 == 0 and n != 0:
print(n + 1)
if n % 2 != 0:
print((n + 1) // 2)
if n == 0:
print(0)
if __name__ == "__main__":
main()
``` | output | 1 | 108,380 | 9 | 216,761 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Katie, Kuro and Shiro are best friends. They have known each other since kindergarten. That's why they often share everything with each other and work together on some very hard problems.
Today is Shiro's birthday. She really loves pizza so she wants to invite her friends to the pizza restaurant near her house to celebrate her birthday, including her best friends Katie and Kuro.
She has ordered a very big round pizza, in order to serve her many friends. Exactly n of Shiro's friends are here. That's why she has to divide the pizza into n + 1 slices (Shiro also needs to eat). She wants the slices to be exactly the same size and shape. If not, some of her friends will get mad and go home early, and the party will be over.
Shiro is now hungry. She wants to cut the pizza with minimum of straight cuts. A cut is a straight segment, it might have ends inside or outside the pizza. But she is too lazy to pick up the calculator.
As usual, she will ask Katie and Kuro for help. But they haven't come yet. Could you help Shiro with this problem?
Input
A single line contains one non-negative integer n (0 ≤ n ≤ 10^{18}) — the number of Shiro's friends. The circular pizza has to be sliced into n + 1 pieces.
Output
A single integer — the number of straight cuts Shiro needs.
Examples
Input
3
Output
2
Input
4
Output
5
Note
To cut the round pizza into quarters one has to make two cuts through the center with angle 90^{\circ} between them.
To cut the round pizza into five equal parts one has to make five cuts. | instruction | 0 | 108,381 | 9 | 216,762 |
Tags: math
Correct Solution:
```
n = int(input())
if n == 0:
print(0)
elif n % 2 == 0:
print(n + 1)
else:
print((n + 1) // 2)
``` | output | 1 | 108,381 | 9 | 216,763 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Katie, Kuro and Shiro are best friends. They have known each other since kindergarten. That's why they often share everything with each other and work together on some very hard problems.
Today is Shiro's birthday. She really loves pizza so she wants to invite her friends to the pizza restaurant near her house to celebrate her birthday, including her best friends Katie and Kuro.
She has ordered a very big round pizza, in order to serve her many friends. Exactly n of Shiro's friends are here. That's why she has to divide the pizza into n + 1 slices (Shiro also needs to eat). She wants the slices to be exactly the same size and shape. If not, some of her friends will get mad and go home early, and the party will be over.
Shiro is now hungry. She wants to cut the pizza with minimum of straight cuts. A cut is a straight segment, it might have ends inside or outside the pizza. But she is too lazy to pick up the calculator.
As usual, she will ask Katie and Kuro for help. But they haven't come yet. Could you help Shiro with this problem?
Input
A single line contains one non-negative integer n (0 ≤ n ≤ 10^{18}) — the number of Shiro's friends. The circular pizza has to be sliced into n + 1 pieces.
Output
A single integer — the number of straight cuts Shiro needs.
Examples
Input
3
Output
2
Input
4
Output
5
Note
To cut the round pizza into quarters one has to make two cuts through the center with angle 90^{\circ} between them.
To cut the round pizza into five equal parts one has to make five cuts. | instruction | 0 | 108,382 | 9 | 216,764 |
Tags: math
Correct Solution:
```
a = int(int(input()) + 1)
if a == 1:
print(0)
elif a % 2 == 0:
print(a//2)
else:
print(a)
``` | output | 1 | 108,382 | 9 | 216,765 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Katie, Kuro and Shiro are best friends. They have known each other since kindergarten. That's why they often share everything with each other and work together on some very hard problems.
Today is Shiro's birthday. She really loves pizza so she wants to invite her friends to the pizza restaurant near her house to celebrate her birthday, including her best friends Katie and Kuro.
She has ordered a very big round pizza, in order to serve her many friends. Exactly n of Shiro's friends are here. That's why she has to divide the pizza into n + 1 slices (Shiro also needs to eat). She wants the slices to be exactly the same size and shape. If not, some of her friends will get mad and go home early, and the party will be over.
Shiro is now hungry. She wants to cut the pizza with minimum of straight cuts. A cut is a straight segment, it might have ends inside or outside the pizza. But she is too lazy to pick up the calculator.
As usual, she will ask Katie and Kuro for help. But they haven't come yet. Could you help Shiro with this problem?
Input
A single line contains one non-negative integer n (0 ≤ n ≤ 10^{18}) — the number of Shiro's friends. The circular pizza has to be sliced into n + 1 pieces.
Output
A single integer — the number of straight cuts Shiro needs.
Examples
Input
3
Output
2
Input
4
Output
5
Note
To cut the round pizza into quarters one has to make two cuts through the center with angle 90^{\circ} between them.
To cut the round pizza into five equal parts one has to make five cuts. | instruction | 0 | 108,383 | 9 | 216,766 |
Tags: math
Correct Solution:
```
n = int(input())
if n % 2 == 1:
print((n + 1) // 2)
elif n == 0:
print(0)
else:
print(n + 1)
``` | output | 1 | 108,383 | 9 | 216,767 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Katie, Kuro and Shiro are best friends. They have known each other since kindergarten. That's why they often share everything with each other and work together on some very hard problems.
Today is Shiro's birthday. She really loves pizza so she wants to invite her friends to the pizza restaurant near her house to celebrate her birthday, including her best friends Katie and Kuro.
She has ordered a very big round pizza, in order to serve her many friends. Exactly n of Shiro's friends are here. That's why she has to divide the pizza into n + 1 slices (Shiro also needs to eat). She wants the slices to be exactly the same size and shape. If not, some of her friends will get mad and go home early, and the party will be over.
Shiro is now hungry. She wants to cut the pizza with minimum of straight cuts. A cut is a straight segment, it might have ends inside or outside the pizza. But she is too lazy to pick up the calculator.
As usual, she will ask Katie and Kuro for help. But they haven't come yet. Could you help Shiro with this problem?
Input
A single line contains one non-negative integer n (0 ≤ n ≤ 10^{18}) — the number of Shiro's friends. The circular pizza has to be sliced into n + 1 pieces.
Output
A single integer — the number of straight cuts Shiro needs.
Examples
Input
3
Output
2
Input
4
Output
5
Note
To cut the round pizza into quarters one has to make two cuts through the center with angle 90^{\circ} between them.
To cut the round pizza into five equal parts one has to make five cuts. | instruction | 0 | 108,384 | 9 | 216,768 |
Tags: math
Correct Solution:
```
n=int(input())+1
print(n//2if n%2==0 or n==1 else n)
``` | output | 1 | 108,384 | 9 | 216,769 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Katie, Kuro and Shiro are best friends. They have known each other since kindergarten. That's why they often share everything with each other and work together on some very hard problems.
Today is Shiro's birthday. She really loves pizza so she wants to invite her friends to the pizza restaurant near her house to celebrate her birthday, including her best friends Katie and Kuro.
She has ordered a very big round pizza, in order to serve her many friends. Exactly n of Shiro's friends are here. That's why she has to divide the pizza into n + 1 slices (Shiro also needs to eat). She wants the slices to be exactly the same size and shape. If not, some of her friends will get mad and go home early, and the party will be over.
Shiro is now hungry. She wants to cut the pizza with minimum of straight cuts. A cut is a straight segment, it might have ends inside or outside the pizza. But she is too lazy to pick up the calculator.
As usual, she will ask Katie and Kuro for help. But they haven't come yet. Could you help Shiro with this problem?
Input
A single line contains one non-negative integer n (0 ≤ n ≤ 10^{18}) — the number of Shiro's friends. The circular pizza has to be sliced into n + 1 pieces.
Output
A single integer — the number of straight cuts Shiro needs.
Examples
Input
3
Output
2
Input
4
Output
5
Note
To cut the round pizza into quarters one has to make two cuts through the center with angle 90^{\circ} between them.
To cut the round pizza into five equal parts one has to make five cuts. | instruction | 0 | 108,385 | 9 | 216,770 |
Tags: math
Correct Solution:
```
n=int(input())
if n==0: print(0)
elif n%2: print((n+1)//2)
else: print(n+1)
``` | output | 1 | 108,385 | 9 | 216,771 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Katie, Kuro and Shiro are best friends. They have known each other since kindergarten. That's why they often share everything with each other and work together on some very hard problems.
Today is Shiro's birthday. She really loves pizza so she wants to invite her friends to the pizza restaurant near her house to celebrate her birthday, including her best friends Katie and Kuro.
She has ordered a very big round pizza, in order to serve her many friends. Exactly n of Shiro's friends are here. That's why she has to divide the pizza into n + 1 slices (Shiro also needs to eat). She wants the slices to be exactly the same size and shape. If not, some of her friends will get mad and go home early, and the party will be over.
Shiro is now hungry. She wants to cut the pizza with minimum of straight cuts. A cut is a straight segment, it might have ends inside or outside the pizza. But she is too lazy to pick up the calculator.
As usual, she will ask Katie and Kuro for help. But they haven't come yet. Could you help Shiro with this problem?
Input
A single line contains one non-negative integer n (0 ≤ n ≤ 10^{18}) — the number of Shiro's friends. The circular pizza has to be sliced into n + 1 pieces.
Output
A single integer — the number of straight cuts Shiro needs.
Examples
Input
3
Output
2
Input
4
Output
5
Note
To cut the round pizza into quarters one has to make two cuts through the center with angle 90^{\circ} between them.
To cut the round pizza into five equal parts one has to make five cuts. | instruction | 0 | 108,386 | 9 | 216,772 |
Tags: math
Correct Solution:
```
def read_nums():
return [int(x) for x in input().split()]
def solve(n):
if n == 0:
print(0)
return
if (n + 1) % 2 == 0:
print((n + 1) // 2)
else:
print(n + 1)
def main():
n, = read_nums()
solve(n)
if __name__ == '__main__':
main()
``` | output | 1 | 108,386 | 9 | 216,773 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Katie, Kuro and Shiro are best friends. They have known each other since kindergarten. That's why they often share everything with each other and work together on some very hard problems.
Today is Shiro's birthday. She really loves pizza so she wants to invite her friends to the pizza restaurant near her house to celebrate her birthday, including her best friends Katie and Kuro.
She has ordered a very big round pizza, in order to serve her many friends. Exactly n of Shiro's friends are here. That's why she has to divide the pizza into n + 1 slices (Shiro also needs to eat). She wants the slices to be exactly the same size and shape. If not, some of her friends will get mad and go home early, and the party will be over.
Shiro is now hungry. She wants to cut the pizza with minimum of straight cuts. A cut is a straight segment, it might have ends inside or outside the pizza. But she is too lazy to pick up the calculator.
As usual, she will ask Katie and Kuro for help. But they haven't come yet. Could you help Shiro with this problem?
Input
A single line contains one non-negative integer n (0 ≤ n ≤ 10^{18}) — the number of Shiro's friends. The circular pizza has to be sliced into n + 1 pieces.
Output
A single integer — the number of straight cuts Shiro needs.
Examples
Input
3
Output
2
Input
4
Output
5
Note
To cut the round pizza into quarters one has to make two cuts through the center with angle 90^{\circ} between them.
To cut the round pizza into five equal parts one has to make five cuts.
Submitted Solution:
```
n=int(input())
if(n==0):
print(0)
else:
if(n%2==1):
print(n//2+1)
else:
print(n+1)
``` | instruction | 0 | 108,387 | 9 | 216,774 |
Yes | output | 1 | 108,387 | 9 | 216,775 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Katie, Kuro and Shiro are best friends. They have known each other since kindergarten. That's why they often share everything with each other and work together on some very hard problems.
Today is Shiro's birthday. She really loves pizza so she wants to invite her friends to the pizza restaurant near her house to celebrate her birthday, including her best friends Katie and Kuro.
She has ordered a very big round pizza, in order to serve her many friends. Exactly n of Shiro's friends are here. That's why she has to divide the pizza into n + 1 slices (Shiro also needs to eat). She wants the slices to be exactly the same size and shape. If not, some of her friends will get mad and go home early, and the party will be over.
Shiro is now hungry. She wants to cut the pizza with minimum of straight cuts. A cut is a straight segment, it might have ends inside or outside the pizza. But she is too lazy to pick up the calculator.
As usual, she will ask Katie and Kuro for help. But they haven't come yet. Could you help Shiro with this problem?
Input
A single line contains one non-negative integer n (0 ≤ n ≤ 10^{18}) — the number of Shiro's friends. The circular pizza has to be sliced into n + 1 pieces.
Output
A single integer — the number of straight cuts Shiro needs.
Examples
Input
3
Output
2
Input
4
Output
5
Note
To cut the round pizza into quarters one has to make two cuts through the center with angle 90^{\circ} between them.
To cut the round pizza into five equal parts one has to make five cuts.
Submitted Solution:
```
n=int(input())
if n==0:
print("0")
exit(0)
n+=1
if n%2==0:
print(n//2)
else:
print(n)
``` | instruction | 0 | 108,388 | 9 | 216,776 |
Yes | output | 1 | 108,388 | 9 | 216,777 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Katie, Kuro and Shiro are best friends. They have known each other since kindergarten. That's why they often share everything with each other and work together on some very hard problems.
Today is Shiro's birthday. She really loves pizza so she wants to invite her friends to the pizza restaurant near her house to celebrate her birthday, including her best friends Katie and Kuro.
She has ordered a very big round pizza, in order to serve her many friends. Exactly n of Shiro's friends are here. That's why she has to divide the pizza into n + 1 slices (Shiro also needs to eat). She wants the slices to be exactly the same size and shape. If not, some of her friends will get mad and go home early, and the party will be over.
Shiro is now hungry. She wants to cut the pizza with minimum of straight cuts. A cut is a straight segment, it might have ends inside or outside the pizza. But she is too lazy to pick up the calculator.
As usual, she will ask Katie and Kuro for help. But they haven't come yet. Could you help Shiro with this problem?
Input
A single line contains one non-negative integer n (0 ≤ n ≤ 10^{18}) — the number of Shiro's friends. The circular pizza has to be sliced into n + 1 pieces.
Output
A single integer — the number of straight cuts Shiro needs.
Examples
Input
3
Output
2
Input
4
Output
5
Note
To cut the round pizza into quarters one has to make two cuts through the center with angle 90^{\circ} between them.
To cut the round pizza into five equal parts one has to make five cuts.
Submitted Solution:
```
n=int(input())
n+=1
if n==1:
print("0")
elif n%2==0:
print(n//2)
else:
print(n)
``` | instruction | 0 | 108,389 | 9 | 216,778 |
Yes | output | 1 | 108,389 | 9 | 216,779 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Katie, Kuro and Shiro are best friends. They have known each other since kindergarten. That's why they often share everything with each other and work together on some very hard problems.
Today is Shiro's birthday. She really loves pizza so she wants to invite her friends to the pizza restaurant near her house to celebrate her birthday, including her best friends Katie and Kuro.
She has ordered a very big round pizza, in order to serve her many friends. Exactly n of Shiro's friends are here. That's why she has to divide the pizza into n + 1 slices (Shiro also needs to eat). She wants the slices to be exactly the same size and shape. If not, some of her friends will get mad and go home early, and the party will be over.
Shiro is now hungry. She wants to cut the pizza with minimum of straight cuts. A cut is a straight segment, it might have ends inside or outside the pizza. But she is too lazy to pick up the calculator.
As usual, she will ask Katie and Kuro for help. But they haven't come yet. Could you help Shiro with this problem?
Input
A single line contains one non-negative integer n (0 ≤ n ≤ 10^{18}) — the number of Shiro's friends. The circular pizza has to be sliced into n + 1 pieces.
Output
A single integer — the number of straight cuts Shiro needs.
Examples
Input
3
Output
2
Input
4
Output
5
Note
To cut the round pizza into quarters one has to make two cuts through the center with angle 90^{\circ} between them.
To cut the round pizza into five equal parts one has to make five cuts.
Submitted Solution:
```
#n, k = map(int, input().split(" ")) # read multiple integers into different variables
#L = [int(x) for x in input().split()] # read multiple integers into a list
#print(' '.join(map(str, L))) # print multiple integers in one line
n = int(input())
if n == 0 : print(0)
elif n % 2 == 0 : print(n + 1)
else : print((n + 1) // 2)
``` | instruction | 0 | 108,390 | 9 | 216,780 |
Yes | output | 1 | 108,390 | 9 | 216,781 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Katie, Kuro and Shiro are best friends. They have known each other since kindergarten. That's why they often share everything with each other and work together on some very hard problems.
Today is Shiro's birthday. She really loves pizza so she wants to invite her friends to the pizza restaurant near her house to celebrate her birthday, including her best friends Katie and Kuro.
She has ordered a very big round pizza, in order to serve her many friends. Exactly n of Shiro's friends are here. That's why she has to divide the pizza into n + 1 slices (Shiro also needs to eat). She wants the slices to be exactly the same size and shape. If not, some of her friends will get mad and go home early, and the party will be over.
Shiro is now hungry. She wants to cut the pizza with minimum of straight cuts. A cut is a straight segment, it might have ends inside or outside the pizza. But she is too lazy to pick up the calculator.
As usual, she will ask Katie and Kuro for help. But they haven't come yet. Could you help Shiro with this problem?
Input
A single line contains one non-negative integer n (0 ≤ n ≤ 10^{18}) — the number of Shiro's friends. The circular pizza has to be sliced into n + 1 pieces.
Output
A single integer — the number of straight cuts Shiro needs.
Examples
Input
3
Output
2
Input
4
Output
5
Note
To cut the round pizza into quarters one has to make two cuts through the center with angle 90^{\circ} between them.
To cut the round pizza into five equal parts one has to make five cuts.
Submitted Solution:
```
n=int(input())
if (n+1)%2==0:
print((n+1)/2)
else:
print(n+1)
``` | instruction | 0 | 108,391 | 9 | 216,782 |
No | output | 1 | 108,391 | 9 | 216,783 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Katie, Kuro and Shiro are best friends. They have known each other since kindergarten. That's why they often share everything with each other and work together on some very hard problems.
Today is Shiro's birthday. She really loves pizza so she wants to invite her friends to the pizza restaurant near her house to celebrate her birthday, including her best friends Katie and Kuro.
She has ordered a very big round pizza, in order to serve her many friends. Exactly n of Shiro's friends are here. That's why she has to divide the pizza into n + 1 slices (Shiro also needs to eat). She wants the slices to be exactly the same size and shape. If not, some of her friends will get mad and go home early, and the party will be over.
Shiro is now hungry. She wants to cut the pizza with minimum of straight cuts. A cut is a straight segment, it might have ends inside or outside the pizza. But she is too lazy to pick up the calculator.
As usual, she will ask Katie and Kuro for help. But they haven't come yet. Could you help Shiro with this problem?
Input
A single line contains one non-negative integer n (0 ≤ n ≤ 10^{18}) — the number of Shiro's friends. The circular pizza has to be sliced into n + 1 pieces.
Output
A single integer — the number of straight cuts Shiro needs.
Examples
Input
3
Output
2
Input
4
Output
5
Note
To cut the round pizza into quarters one has to make two cuts through the center with angle 90^{\circ} between them.
To cut the round pizza into five equal parts one has to make five cuts.
Submitted Solution:
```
n=int(input())
if n%2==0:
print(n+1)
else:
print(n-1)
``` | instruction | 0 | 108,392 | 9 | 216,784 |
No | output | 1 | 108,392 | 9 | 216,785 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Katie, Kuro and Shiro are best friends. They have known each other since kindergarten. That's why they often share everything with each other and work together on some very hard problems.
Today is Shiro's birthday. She really loves pizza so she wants to invite her friends to the pizza restaurant near her house to celebrate her birthday, including her best friends Katie and Kuro.
She has ordered a very big round pizza, in order to serve her many friends. Exactly n of Shiro's friends are here. That's why she has to divide the pizza into n + 1 slices (Shiro also needs to eat). She wants the slices to be exactly the same size and shape. If not, some of her friends will get mad and go home early, and the party will be over.
Shiro is now hungry. She wants to cut the pizza with minimum of straight cuts. A cut is a straight segment, it might have ends inside or outside the pizza. But she is too lazy to pick up the calculator.
As usual, she will ask Katie and Kuro for help. But they haven't come yet. Could you help Shiro with this problem?
Input
A single line contains one non-negative integer n (0 ≤ n ≤ 10^{18}) — the number of Shiro's friends. The circular pizza has to be sliced into n + 1 pieces.
Output
A single integer — the number of straight cuts Shiro needs.
Examples
Input
3
Output
2
Input
4
Output
5
Note
To cut the round pizza into quarters one has to make two cuts through the center with angle 90^{\circ} between them.
To cut the round pizza into five equal parts one has to make five cuts.
Submitted Solution:
```
n = int(input())
c=0
if(n == 0):
c = n
elif(n % 2 == 0):
c = n+1
else:
c = (n+1)/2
print(c)
``` | instruction | 0 | 108,393 | 9 | 216,786 |
No | output | 1 | 108,393 | 9 | 216,787 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Katie, Kuro and Shiro are best friends. They have known each other since kindergarten. That's why they often share everything with each other and work together on some very hard problems.
Today is Shiro's birthday. She really loves pizza so she wants to invite her friends to the pizza restaurant near her house to celebrate her birthday, including her best friends Katie and Kuro.
She has ordered a very big round pizza, in order to serve her many friends. Exactly n of Shiro's friends are here. That's why she has to divide the pizza into n + 1 slices (Shiro also needs to eat). She wants the slices to be exactly the same size and shape. If not, some of her friends will get mad and go home early, and the party will be over.
Shiro is now hungry. She wants to cut the pizza with minimum of straight cuts. A cut is a straight segment, it might have ends inside or outside the pizza. But she is too lazy to pick up the calculator.
As usual, she will ask Katie and Kuro for help. But they haven't come yet. Could you help Shiro with this problem?
Input
A single line contains one non-negative integer n (0 ≤ n ≤ 10^{18}) — the number of Shiro's friends. The circular pizza has to be sliced into n + 1 pieces.
Output
A single integer — the number of straight cuts Shiro needs.
Examples
Input
3
Output
2
Input
4
Output
5
Note
To cut the round pizza into quarters one has to make two cuts through the center with angle 90^{\circ} between them.
To cut the round pizza into five equal parts one has to make five cuts.
Submitted Solution:
```
a = int(input())+1
if a==1:
print(0)
if a%2 ==0:
print(int(a//2))
else:
print(a)
``` | instruction | 0 | 108,394 | 9 | 216,788 |
No | output | 1 | 108,394 | 9 | 216,789 |
Provide a correct Python 3 solution for this coding contest problem.
There are N barbecue restaurants along a street. The restaurants are numbered 1 through N from west to east, and the distance between restaurant i and restaurant i+1 is A_i.
Joisino has M tickets, numbered 1 through M. Every barbecue restaurant offers barbecue meals in exchange for these tickets. Restaurant i offers a meal of deliciousness B_{i,j} in exchange for ticket j. Each ticket can only be used once, but any number of tickets can be used at a restaurant.
Joisino wants to have M barbecue meals by starting from a restaurant of her choice, then repeatedly traveling to another barbecue restaurant and using unused tickets at the restaurant at her current location. Her eventual happiness is calculated by the following formula: "(The total deliciousness of the meals eaten) - (The total distance traveled)". Find her maximum possible eventual happiness.
Constraints
* All input values are integers.
* 2≤N≤5×10^3
* 1≤M≤200
* 1≤A_i≤10^9
* 1≤B_{i,j}≤10^9
Input
The input is given from Standard Input in the following format:
N M
A_1 A_2 ... A_{N-1}
B_{1,1} B_{1,2} ... B_{1,M}
B_{2,1} B_{2,2} ... B_{2,M}
:
B_{N,1} B_{N,2} ... B_{N,M}
Output
Print Joisino's maximum possible eventual happiness.
Examples
Input
3 4
1 4
2 2 5 1
1 3 3 2
2 2 5 1
Output
11
Input
5 3
1 2 3 4
10 1 1
1 1 1
1 10 1
1 1 1
1 1 10
Output
20 | instruction | 0 | 108,516 | 9 | 217,032 |
"Correct Solution:
```
import sys
readline = sys.stdin.readline
N, M = map(int, readline().split())
A = [0] + list(map(int, readline().split()))
for i in range(1, N):
A[i] += A[i-1]
INF = 10**9+7
B = [list(map(int, readline().split())) for _ in range(N)] + [[INF]*M] + [[0]*M]
right = [[0]*M for _ in range(N)]
for m in range(M):
L = list(range(N))
L.sort(key = lambda x: B[x][m])
RR = list(range(1, N+3))
LL = list(range(-1, N+1))
for vn in L:
vn += 1
right[vn-1][m] = RR[vn]-1
RR[LL[vn]] = RR[vn]
LL[RR[vn]] = LL[vn]
diff = [0]*(N+1)
for m in range(M):
diff[0] += B[0][m]
pre = B[0][m]
for i in range(1, N):
if B[i][m] > pre:
diff[i] += B[i][m]-pre
pre = B[i][m]
offset = 0
ans = 0
for l in range(N):
offset += diff[l]
for m in range(M):
if B[l][m] < B[l-1][m]:
oldr = right[l-1][m]
diff[oldr] -= B[oldr][m] - B[l-1][m]
offset += B[l][m] - B[l-1][m]
cnt = l
while cnt < N and right[cnt][m] <= oldr:
rcm = right[cnt][m]
diff[rcm] += B[rcm][m] - B[cnt][m]
cnt = rcm
ans = max(ans, offset)
roff = offset
for r in range(l+1, N):
roff += diff[r]
ans = max(ans, roff - (A[r]-A[l]))
#print(l, r, roff - (A[r] - A[l]))
print(ans)
``` | output | 1 | 108,516 | 9 | 217,033 |
Provide a correct Python 3 solution for this coding contest problem.
There are N barbecue restaurants along a street. The restaurants are numbered 1 through N from west to east, and the distance between restaurant i and restaurant i+1 is A_i.
Joisino has M tickets, numbered 1 through M. Every barbecue restaurant offers barbecue meals in exchange for these tickets. Restaurant i offers a meal of deliciousness B_{i,j} in exchange for ticket j. Each ticket can only be used once, but any number of tickets can be used at a restaurant.
Joisino wants to have M barbecue meals by starting from a restaurant of her choice, then repeatedly traveling to another barbecue restaurant and using unused tickets at the restaurant at her current location. Her eventual happiness is calculated by the following formula: "(The total deliciousness of the meals eaten) - (The total distance traveled)". Find her maximum possible eventual happiness.
Constraints
* All input values are integers.
* 2≤N≤5×10^3
* 1≤M≤200
* 1≤A_i≤10^9
* 1≤B_{i,j}≤10^9
Input
The input is given from Standard Input in the following format:
N M
A_1 A_2 ... A_{N-1}
B_{1,1} B_{1,2} ... B_{1,M}
B_{2,1} B_{2,2} ... B_{2,M}
:
B_{N,1} B_{N,2} ... B_{N,M}
Output
Print Joisino's maximum possible eventual happiness.
Examples
Input
3 4
1 4
2 2 5 1
1 3 3 2
2 2 5 1
Output
11
Input
5 3
1 2 3 4
10 1 1
1 1 1
1 10 1
1 1 1
1 1 10
Output
20 | instruction | 0 | 108,517 | 9 | 217,034 |
"Correct Solution:
```
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
import itertools
INF=10**10
N,M = map(int,readline().split())
A = [0,0]+list(map(int,readline().split()))
B = [[INF]*M]+[list(map(int,line.split())) for line in readlines()]
for i in range(1,N+1):
A[i] += A[i-1]
answer = 0
INF = 10**12
diff = [INF]+[0]*N
left = [list(range(-1,N)) for m in range(M)]
arr = [INF,2,1,2]
for i in range(1,N+1):
for m in range(M):
p=i; prev_val=0
q=left[m][p]
x = B[i][m]
while prev_val<=x:
diff[p] += x-prev_val
diff[q] -= x-prev_val
p=q; q=left[m][p]
prev_val=B[p][m]
left[m][i]=p
# 出発地点ごとの収入
ticket_sum = list(itertools.accumulate(diff[::-1]))[::-1]
for start in range(1,i+1):
happy = ticket_sum[start] + A[start]-A[i]
if answer < happy:
answer = happy
print(answer)
``` | output | 1 | 108,517 | 9 | 217,035 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N barbecue restaurants along a street. The restaurants are numbered 1 through N from west to east, and the distance between restaurant i and restaurant i+1 is A_i.
Joisino has M tickets, numbered 1 through M. Every barbecue restaurant offers barbecue meals in exchange for these tickets. Restaurant i offers a meal of deliciousness B_{i,j} in exchange for ticket j. Each ticket can only be used once, but any number of tickets can be used at a restaurant.
Joisino wants to have M barbecue meals by starting from a restaurant of her choice, then repeatedly traveling to another barbecue restaurant and using unused tickets at the restaurant at her current location. Her eventual happiness is calculated by the following formula: "(The total deliciousness of the meals eaten) - (The total distance traveled)". Find her maximum possible eventual happiness.
Constraints
* All input values are integers.
* 2≤N≤5×10^3
* 1≤M≤200
* 1≤A_i≤10^9
* 1≤B_{i,j}≤10^9
Input
The input is given from Standard Input in the following format:
N M
A_1 A_2 ... A_{N-1}
B_{1,1} B_{1,2} ... B_{1,M}
B_{2,1} B_{2,2} ... B_{2,M}
:
B_{N,1} B_{N,2} ... B_{N,M}
Output
Print Joisino's maximum possible eventual happiness.
Examples
Input
3 4
1 4
2 2 5 1
1 3 3 2
2 2 5 1
Output
11
Input
5 3
1 2 3 4
10 1 1
1 1 1
1 10 1
1 1 1
1 1 10
Output
20
Submitted Solution:
```
import sys
readline = sys.stdin.readline
class Sparsetable:
def __init__(self, B):
self.B = B
self.N = len(B)
A = list(range(self.N))
self.bn = self.N.bit_length()
self.res = [[None]*self.bn for _ in range(self.N)]
for i in range(self.N):
self.res[i][0] = A[i]
for dn in range(1, self.bn):
rn = 1<<(dn-1)
for h in range(self.N-2*rn+1):
self.res[h][dn] = self.spf(self.res[h][dn-1], self.res[h+rn][dn-1])
def spf(self, x, y):
if self.B[x] > self.B[y]:
return x
return y
def query(self, h1, h2):
h2 -= 1
hl = h2-h1+1
bh = hl.bit_length()-1
rh = 1<<bh
return self.spf(self.res[h1][bh], self.res[h2-rh+1][bh])
N, M = map(int, readline().split())
A = [0] + list(map(int, readline().split())) + [0]
for i in range(1, N):
A[i] += A[i-1]
B = [list(map(int, readline().split())) for _ in range(N)]
B = list(map(list, zip(*B)))
table = [[0]*(N+1) for _ in range(N+1)]
for j in range(M):
St = Sparsetable(B[j])
stack = [(0, N)]
while stack:
l, r = stack.pop()
am = St.query(l, r)
b = B[j][am]
table[l][r-1] += b
table[l][am-1] -= b
table[am+1][r-1] -= b
table[am+1][am-1] += b
if am != l:
stack.append((l, am))
if am+1 != r:
stack.append((am+1, r))
for r in range(N-1, -1, -1):
for l in range(1, r+1):
table[l][r] += table[l-1][r]
for r in range(N-2, -1, -1):
for l in range(r+1):
table[l][r] += table[l][r+1]
ans = 0
for i in range(N):
for j in range(i+1, N+1):
ans = max(ans, table[i][j-1] - (A[j-1] - A[i]))
print(ans)
``` | instruction | 0 | 108,518 | 9 | 217,036 |
No | output | 1 | 108,518 | 9 | 217,037 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N barbecue restaurants along a street. The restaurants are numbered 1 through N from west to east, and the distance between restaurant i and restaurant i+1 is A_i.
Joisino has M tickets, numbered 1 through M. Every barbecue restaurant offers barbecue meals in exchange for these tickets. Restaurant i offers a meal of deliciousness B_{i,j} in exchange for ticket j. Each ticket can only be used once, but any number of tickets can be used at a restaurant.
Joisino wants to have M barbecue meals by starting from a restaurant of her choice, then repeatedly traveling to another barbecue restaurant and using unused tickets at the restaurant at her current location. Her eventual happiness is calculated by the following formula: "(The total deliciousness of the meals eaten) - (The total distance traveled)". Find her maximum possible eventual happiness.
Constraints
* All input values are integers.
* 2≤N≤5×10^3
* 1≤M≤200
* 1≤A_i≤10^9
* 1≤B_{i,j}≤10^9
Input
The input is given from Standard Input in the following format:
N M
A_1 A_2 ... A_{N-1}
B_{1,1} B_{1,2} ... B_{1,M}
B_{2,1} B_{2,2} ... B_{2,M}
:
B_{N,1} B_{N,2} ... B_{N,M}
Output
Print Joisino's maximum possible eventual happiness.
Examples
Input
3 4
1 4
2 2 5 1
1 3 3 2
2 2 5 1
Output
11
Input
5 3
1 2 3 4
10 1 1
1 1 1
1 10 1
1 1 1
1 1 10
Output
20
Submitted Solution:
```
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
from numba import jit
import numpy as np
n,m = map(int,readline().split())
a = list(map(int,readline().split()))
a += [0,0,0]
b = list(map(int,read().split()))
@jit
def solve(n,m,a,b):
# imos = [[0] * (n+2) for _ in range(n+2)]
imos = np.zeros((n+2,n+2))
for i in range(m):
left = list(range(-1,n+1))
right = list(range(1,n+3))
bi = [(val,j) for j,val in enumerate(b[i::m], 1)]
bi.sort()
for val,j in bi:
l = left[j]
r = right[j]
imos[l+1,j] += val
imos[l+1,r] -= val
imos[j+1,j] -= val
imos[j+1,r] += val
right[l] = r
left[r] = l
for i in range(n+1):
for j in range(1,n+1):
imos[i,j] += imos[i,j-1]
for i in range(1,n+1):
for j in range(n+1):
imos[i,j] += imos[i-1,j]
ans = 0
for i in range(1,n+1):
dif = 0
for j in range(i,n+1):
ans = max(ans,imos[i,j] - dif)
dif += a[j-1]
print(int(ans))
solve(n,m,a,b)
``` | instruction | 0 | 108,519 | 9 | 217,038 |
No | output | 1 | 108,519 | 9 | 217,039 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N barbecue restaurants along a street. The restaurants are numbered 1 through N from west to east, and the distance between restaurant i and restaurant i+1 is A_i.
Joisino has M tickets, numbered 1 through M. Every barbecue restaurant offers barbecue meals in exchange for these tickets. Restaurant i offers a meal of deliciousness B_{i,j} in exchange for ticket j. Each ticket can only be used once, but any number of tickets can be used at a restaurant.
Joisino wants to have M barbecue meals by starting from a restaurant of her choice, then repeatedly traveling to another barbecue restaurant and using unused tickets at the restaurant at her current location. Her eventual happiness is calculated by the following formula: "(The total deliciousness of the meals eaten) - (The total distance traveled)". Find her maximum possible eventual happiness.
Constraints
* All input values are integers.
* 2≤N≤5×10^3
* 1≤M≤200
* 1≤A_i≤10^9
* 1≤B_{i,j}≤10^9
Input
The input is given from Standard Input in the following format:
N M
A_1 A_2 ... A_{N-1}
B_{1,1} B_{1,2} ... B_{1,M}
B_{2,1} B_{2,2} ... B_{2,M}
:
B_{N,1} B_{N,2} ... B_{N,M}
Output
Print Joisino's maximum possible eventual happiness.
Examples
Input
3 4
1 4
2 2 5 1
1 3 3 2
2 2 5 1
Output
11
Input
5 3
1 2 3 4
10 1 1
1 1 1
1 10 1
1 1 1
1 1 10
Output
20
Submitted Solution:
```
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
N,M = map(int,readline().split())
A = [0]+list(map(int,readline().split()))
B = list(map(int,read().split()))
N,M
for i in range(1,N):
A[i] += A[i-1]
ticket_sum = [0]*(N*N)
# 各区間 [L,R] に対して、採用される点数を見る
for n in range(M):
arr = B[n::M]
# 安いチケットから入れていく -> 連結成分上で採用される
left = list(range(N))
right = list(range(N))
filled = [False]*N
for i in sorted(range(N), key=arr.__getitem__):
filled[i] = True
l = i if (i==0) or (not filled[i-1]) else left[i-1]
r = i if (i==N-1) or (not filled[i+1]) else right[i+1]
left[r] = l; right[l] = r
# [l,i] x [i,r] に arr[i] を加える
x = arr[i]
ticket_sum[l*N+i]+=x
if i<N-1:
ticket_sum[(i+1)*N+i]-=x
if r<N-1:
ticket_sum[l*N+r+1]-=x
if i<N-1 and r<N-1:
ticket_sum[(i+1)*N+r+1]+=x
``` | instruction | 0 | 108,520 | 9 | 217,040 |
No | output | 1 | 108,520 | 9 | 217,041 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N barbecue restaurants along a street. The restaurants are numbered 1 through N from west to east, and the distance between restaurant i and restaurant i+1 is A_i.
Joisino has M tickets, numbered 1 through M. Every barbecue restaurant offers barbecue meals in exchange for these tickets. Restaurant i offers a meal of deliciousness B_{i,j} in exchange for ticket j. Each ticket can only be used once, but any number of tickets can be used at a restaurant.
Joisino wants to have M barbecue meals by starting from a restaurant of her choice, then repeatedly traveling to another barbecue restaurant and using unused tickets at the restaurant at her current location. Her eventual happiness is calculated by the following formula: "(The total deliciousness of the meals eaten) - (The total distance traveled)". Find her maximum possible eventual happiness.
Constraints
* All input values are integers.
* 2≤N≤5×10^3
* 1≤M≤200
* 1≤A_i≤10^9
* 1≤B_{i,j}≤10^9
Input
The input is given from Standard Input in the following format:
N M
A_1 A_2 ... A_{N-1}
B_{1,1} B_{1,2} ... B_{1,M}
B_{2,1} B_{2,2} ... B_{2,M}
:
B_{N,1} B_{N,2} ... B_{N,M}
Output
Print Joisino's maximum possible eventual happiness.
Examples
Input
3 4
1 4
2 2 5 1
1 3 3 2
2 2 5 1
Output
11
Input
5 3
1 2 3 4
10 1 1
1 1 1
1 10 1
1 1 1
1 1 10
Output
20
Submitted Solution:
```
def main():
from sys import stdin
read = stdin.buffer.read
readline = stdin.buffer.readline
from collections import defaultdict
from itertools import accumulate
n,m = map(int,readline().split())
a = tuple(map(int,readline().split()))
b = tuple(map(int,read().split()))
query = [defaultdict(int) for _ in range(n+2)]
for i in range(m):
left = list(range(-1,n+1))
right = list(range(1,n+3))
bi = [(val,j) for j,val in enumerate(b[i::m], 1)]
bi.sort()
for val,j in bi:
l = left[j]
r = right[j]
query[l+1][j] += val
query[l+1][r] -= val
query[j+1][j] -= val
query[j+1][r] += val
right[l] = r
left[r] = l
imos = [0] * (n+2)
for i,ai in enumerate(a,2):
imos[i] = imos[i-1] - ai
query[i][i] += ai
ans = 0
for i in range(1,n+1):
next = [0] * (n+3-i)
for j,val in query[i].items():
next[j+1-i] += val
for j,val in enumerate(accumulate(next),i-1):
imos[j] += val
ans = max(ans, max(imos[i:n+1]))
print(ans)
if __name__ == '__main__':
main()
``` | instruction | 0 | 108,521 | 9 | 217,042 |
No | output | 1 | 108,521 | 9 | 217,043 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.