message stringlengths 2 67k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 463 109k | cluster float64 19 19 | __index_level_0__ int64 926 217k |
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Manao is trying to open a rather challenging lock. The lock has n buttons on it and to open it, you should press the buttons in a certain order to open the lock. When you push some button, it either stays pressed into the lock (that means that you've guessed correctly and pushed the button that goes next in the sequence), or all pressed buttons return to the initial position. When all buttons are pressed into the lock at once, the lock opens.
Consider an example with three buttons. Let's say that the opening sequence is: {2, 3, 1}. If you first press buttons 1 or 3, the buttons unpress immediately. If you first press button 2, it stays pressed. If you press 1 after 2, all buttons unpress. If you press 3 after 2, buttons 3 and 2 stay pressed. As soon as you've got two pressed buttons, you only need to press button 1 to open the lock.
Manao doesn't know the opening sequence. But he is really smart and he is going to act in the optimal way. Calculate the number of times he's got to push a button in order to open the lock in the worst-case scenario.
Input
A single line contains integer n (1 β€ n β€ 2000) β the number of buttons the lock has.
Output
In a single line print the number of times Manao has to push a button in the worst-case scenario.
Examples
Input
2
Output
3
Input
3
Output
7
Note
Consider the first test sample. Manao can fail his first push and push the wrong button. In this case he will already be able to guess the right one with his second push. And his third push will push the second right button. Thus, in the worst-case scenario he will only need 3 pushes.
Submitted Solution:
```
n = int(input())
print(2)
``` | instruction | 0 | 2,765 | 19 | 5,530 |
No | output | 1 | 2,765 | 19 | 5,531 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Manao is trying to open a rather challenging lock. The lock has n buttons on it and to open it, you should press the buttons in a certain order to open the lock. When you push some button, it either stays pressed into the lock (that means that you've guessed correctly and pushed the button that goes next in the sequence), or all pressed buttons return to the initial position. When all buttons are pressed into the lock at once, the lock opens.
Consider an example with three buttons. Let's say that the opening sequence is: {2, 3, 1}. If you first press buttons 1 or 3, the buttons unpress immediately. If you first press button 2, it stays pressed. If you press 1 after 2, all buttons unpress. If you press 3 after 2, buttons 3 and 2 stay pressed. As soon as you've got two pressed buttons, you only need to press button 1 to open the lock.
Manao doesn't know the opening sequence. But he is really smart and he is going to act in the optimal way. Calculate the number of times he's got to push a button in order to open the lock in the worst-case scenario.
Input
A single line contains integer n (1 β€ n β€ 2000) β the number of buttons the lock has.
Output
In a single line print the number of times Manao has to push a button in the worst-case scenario.
Examples
Input
2
Output
3
Input
3
Output
7
Note
Consider the first test sample. Manao can fail his first push and push the wrong button. In this case he will already be able to guess the right one with his second push. And his third push will push the second right button. Thus, in the worst-case scenario he will only need 3 pushes.
Submitted Solution:
```
import math
n = int(input())
if n % 2 == 0:
print(math.floor(math.exp(n)/n))
else:
print(math.ceil(math.exp(n)/n))
``` | instruction | 0 | 2,766 | 19 | 5,532 |
No | output | 1 | 2,766 | 19 | 5,533 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Manao is trying to open a rather challenging lock. The lock has n buttons on it and to open it, you should press the buttons in a certain order to open the lock. When you push some button, it either stays pressed into the lock (that means that you've guessed correctly and pushed the button that goes next in the sequence), or all pressed buttons return to the initial position. When all buttons are pressed into the lock at once, the lock opens.
Consider an example with three buttons. Let's say that the opening sequence is: {2, 3, 1}. If you first press buttons 1 or 3, the buttons unpress immediately. If you first press button 2, it stays pressed. If you press 1 after 2, all buttons unpress. If you press 3 after 2, buttons 3 and 2 stay pressed. As soon as you've got two pressed buttons, you only need to press button 1 to open the lock.
Manao doesn't know the opening sequence. But he is really smart and he is going to act in the optimal way. Calculate the number of times he's got to push a button in order to open the lock in the worst-case scenario.
Input
A single line contains integer n (1 β€ n β€ 2000) β the number of buttons the lock has.
Output
In a single line print the number of times Manao has to push a button in the worst-case scenario.
Examples
Input
2
Output
3
Input
3
Output
7
Note
Consider the first test sample. Manao can fail his first push and push the wrong button. In this case he will already be able to guess the right one with his second push. And his third push will push the second right button. Thus, in the worst-case scenario he will only need 3 pushes.
Submitted Solution:
```
#!/usr/bin/env python
# coding: utf-8
# In[ ]:
n = int(input())
print(int(n*(n-1)/2+1))
``` | instruction | 0 | 2,767 | 19 | 5,534 |
No | output | 1 | 2,767 | 19 | 5,535 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Radewoosh is playing a computer game. There are n levels, numbered 1 through n. Levels are divided into k regions (groups). Each region contains some positive number of consecutive levels.
The game repeats the the following process:
1. If all regions are beaten then the game ends immediately. Otherwise, the system finds the first region with at least one non-beaten level. Let X denote this region.
2. The system creates an empty bag for tokens. Each token will represent one level and there may be many tokens representing the same level.
* For each already beaten level i in the region X, the system adds ti tokens to the bag (tokens representing the i-th level).
* Let j denote the first non-beaten level in the region X. The system adds tj tokens to the bag.
3. Finally, the system takes a uniformly random token from the bag and a player starts the level represented by the token. A player spends one hour and beats the level, even if he has already beaten it in the past.
Given n, k and values t1, t2, ..., tn, your task is to split levels into regions. Each level must belong to exactly one region, and each region must contain non-empty consecutive set of levels. What is the minimum possible expected number of hours required to finish the game?
Input
The first line of the input contains two integers n and k (1 β€ n β€ 200 000, 1 β€ k β€ min(50, n)) β the number of levels and the number of regions, respectively.
The second line contains n integers t1, t2, ..., tn (1 β€ ti β€ 100 000).
Output
Print one real number β the minimum possible expected value of the number of hours spent to finish the game if levels are distributed between regions in the optimal way. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 4.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct if <image>.
Examples
Input
4 2
100 3 5 7
Output
5.7428571429
Input
6 2
1 2 4 8 16 32
Output
8.5000000000
Note
In the first sample, we are supposed to split 4 levels into 2 regions. It's optimal to create the first region with only one level (it must be the first level). Then, the second region must contain other three levels.
In the second sample, it's optimal to split levels into two regions with 3 levels each.
Submitted Solution:
```
import sys
import math
import itertools as it
import operator as op
import fractions as fr
n,k = map(int,sys.stdin.readline().split())
T = list(map(int,sys.stdin.readline().split()))
def split(l,r):
min_rl = 100000.0
min_rr = 100000.0
min_pos = -1
for k in range(l+1,r):
left = 0.0
s = 0.0
for i in range(l,k):
s += T[i]
left += s / T[i]
right = 0.0
s = 0.0
for i in range(k,r):
s += T[i]
right += s / T[i]
if min_rl + min_rr > left + right or min_pos == -1:
min_rl = left
min_rr = right
min_pos = k
return min_rl, min_rr, min_pos
d = {(0,n): n}
while len(d) != k:
(l,r) = max(d.items(), key = lambda e: e[1])[0]
min_rl, min_rr, min_pos = split(l,r)
del d[(l,r)]
d[(l,min_pos)] = min_rl
d[(min_pos,r)] = min_rr
print(sum(d.values()))
``` | instruction | 0 | 2,933 | 19 | 5,866 |
No | output | 1 | 2,933 | 19 | 5,867 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Radewoosh is playing a computer game. There are n levels, numbered 1 through n. Levels are divided into k regions (groups). Each region contains some positive number of consecutive levels.
The game repeats the the following process:
1. If all regions are beaten then the game ends immediately. Otherwise, the system finds the first region with at least one non-beaten level. Let X denote this region.
2. The system creates an empty bag for tokens. Each token will represent one level and there may be many tokens representing the same level.
* For each already beaten level i in the region X, the system adds ti tokens to the bag (tokens representing the i-th level).
* Let j denote the first non-beaten level in the region X. The system adds tj tokens to the bag.
3. Finally, the system takes a uniformly random token from the bag and a player starts the level represented by the token. A player spends one hour and beats the level, even if he has already beaten it in the past.
Given n, k and values t1, t2, ..., tn, your task is to split levels into regions. Each level must belong to exactly one region, and each region must contain non-empty consecutive set of levels. What is the minimum possible expected number of hours required to finish the game?
Input
The first line of the input contains two integers n and k (1 β€ n β€ 200 000, 1 β€ k β€ min(50, n)) β the number of levels and the number of regions, respectively.
The second line contains n integers t1, t2, ..., tn (1 β€ ti β€ 100 000).
Output
Print one real number β the minimum possible expected value of the number of hours spent to finish the game if levels are distributed between regions in the optimal way. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 4.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct if <image>.
Examples
Input
4 2
100 3 5 7
Output
5.7428571429
Input
6 2
1 2 4 8 16 32
Output
8.5000000000
Note
In the first sample, we are supposed to split 4 levels into 2 regions. It's optimal to create the first region with only one level (it must be the first level). Then, the second region must contain other three levels.
In the second sample, it's optimal to split levels into two regions with 3 levels each.
Submitted Solution:
```
import sys
import math
import itertools as it
import operator as op
import fractions as fr
n,k = map(int,sys.stdin.readline().split())
T = list(map(int,sys.stdin.readline().split()))
def split(l,r):
min_rl = 100000.0
min_rr = 100000.0
min_pos = -1
for k in range(l+1,r):
left = 0.0
s = 0.0
for i in range(l,k):
s += T[i]
left += s / T[i]
right = 0.0
s = 0.0
for i in range(k,r):
s += T[i]
right += s / T[i]
if min_rl + min_rr > left + right or min_pos == -1:
min_rl = left
min_rr = right
min_pos = k
return min_rl, min_rr, min_pos
d = {(0,n): n}
while len(d) != k:
(l,r) = min(d.items(), key = lambda e: e[1])[0]
min_rl, min_rr, min_pos = split(l,r)
del d[(l,r)]
d[(l,min_pos)] = min_rl
d[(min_pos,r)] = min_rr
print(sum(d.values()))
``` | instruction | 0 | 2,934 | 19 | 5,868 |
No | output | 1 | 2,934 | 19 | 5,869 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Radewoosh is playing a computer game. There are n levels, numbered 1 through n. Levels are divided into k regions (groups). Each region contains some positive number of consecutive levels.
The game repeats the the following process:
1. If all regions are beaten then the game ends immediately. Otherwise, the system finds the first region with at least one non-beaten level. Let X denote this region.
2. The system creates an empty bag for tokens. Each token will represent one level and there may be many tokens representing the same level.
* For each already beaten level i in the region X, the system adds ti tokens to the bag (tokens representing the i-th level).
* Let j denote the first non-beaten level in the region X. The system adds tj tokens to the bag.
3. Finally, the system takes a uniformly random token from the bag and a player starts the level represented by the token. A player spends one hour and beats the level, even if he has already beaten it in the past.
Given n, k and values t1, t2, ..., tn, your task is to split levels into regions. Each level must belong to exactly one region, and each region must contain non-empty consecutive set of levels. What is the minimum possible expected number of hours required to finish the game?
Input
The first line of the input contains two integers n and k (1 β€ n β€ 200 000, 1 β€ k β€ min(50, n)) β the number of levels and the number of regions, respectively.
The second line contains n integers t1, t2, ..., tn (1 β€ ti β€ 100 000).
Output
Print one real number β the minimum possible expected value of the number of hours spent to finish the game if levels are distributed between regions in the optimal way. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 4.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct if <image>.
Examples
Input
4 2
100 3 5 7
Output
5.7428571429
Input
6 2
1 2 4 8 16 32
Output
8.5000000000
Note
In the first sample, we are supposed to split 4 levels into 2 regions. It's optimal to create the first region with only one level (it must be the first level). Then, the second region must contain other three levels.
In the second sample, it's optimal to split levels into two regions with 3 levels each.
Submitted Solution:
```
import sys
import math
import itertools as it
import operator as op
import fractions as fr
n,k = map(int,sys.stdin.readline().split())
T = list(map(int,sys.stdin.readline().split()))
def price(l,r):
price = 0.0
s = 0.0
for i in range(l,r):
s += T[i]
price += s / T[i]
return price
def split(l,r):
min_rl = 100000.0
min_rr = 100000.0
min_pos = -1
for k in range(l+1,r):
left = price(l,k)
right = price(k,r)
if min_rl + min_rr > left + right or min_pos == -1:
min_rl = left
min_rr = right
min_pos = k
return min_rl, min_rr, min_pos
d = {(0,n): price(0,n)}
while len(d) != k:
(l,r) = max(d.items(), key = lambda e: e[1])[0]
min_rl, min_rr, min_pos = split(l,r)
del d[(l,r)]
d[(l,min_pos)] = min_rl
d[(min_pos,r)] = min_rr
print(sum(d.values()))
``` | instruction | 0 | 2,935 | 19 | 5,870 |
No | output | 1 | 2,935 | 19 | 5,871 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasily has a deck of cards consisting of n cards. There is an integer on each of the cards, this integer is between 1 and 100 000, inclusive. It is possible that some cards have the same integers on them.
Vasily decided to sort the cards. To do this, he repeatedly takes the top card from the deck, and if the number on it equals the minimum number written on the cards in the deck, then he places the card away. Otherwise, he puts it under the deck and takes the next card from the top, and so on. The process ends as soon as there are no cards in the deck. You can assume that Vasily always knows the minimum number written on some card in the remaining deck, but doesn't know where this card (or these cards) is.
You are to determine the total number of times Vasily takes the top card from the deck.
Input
The first line contains single integer n (1 β€ n β€ 100 000) β the number of cards in the deck.
The second line contains a sequence of n integers a1, a2, ..., an (1 β€ ai β€ 100 000), where ai is the number written on the i-th from top card in the deck.
Output
Print the total number of times Vasily takes the top card from the deck.
Examples
Input
4
6 3 1 2
Output
7
Input
1
1000
Output
1
Input
7
3 3 3 3 3 3 3
Output
7
Note
In the first example Vasily at first looks at the card with number 6 on it, puts it under the deck, then on the card with number 3, puts it under the deck, and then on the card with number 1. He places away the card with 1, because the number written on it is the minimum among the remaining cards. After that the cards from top to bottom are [2, 6, 3]. Then Vasily looks at the top card with number 2 and puts it away. After that the cards from top to bottom are [6, 3]. Then Vasily looks at card 6, puts it under the deck, then at card 3 and puts it away. Then there is only one card with number 6 on it, and Vasily looks at it and puts it away. Thus, in total Vasily looks at 7 cards. | instruction | 0 | 3,020 | 19 | 6,040 |
Tags: data structures, implementation, sortings
Correct Solution:
```
from collections import deque
import heapq
n = int(input())
cards_help = list(map(int, input().split()))
cards = [ (cards_help[i],-1*i) for i in range(n) ]
heapq.heapify(cards)
draws = 0
removed = 0
while cards:
prev = -1
new_removals = 0
current = cards[0]
while cards and -1*current[1] > prev:
new_removals += 1
heapq.heappop(cards)
temp_prev = -1*current[1]
while cards and cards[0][0] == current[0] and -1*cards[0][1] > prev:
current = cards[0]
heapq.heappop(cards)
new_removals += 1
prev = temp_prev
current = cards[0] if cards else 0
draws += n - removed
removed += new_removals
print(draws)
``` | output | 1 | 3,020 | 19 | 6,041 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasily has a deck of cards consisting of n cards. There is an integer on each of the cards, this integer is between 1 and 100 000, inclusive. It is possible that some cards have the same integers on them.
Vasily decided to sort the cards. To do this, he repeatedly takes the top card from the deck, and if the number on it equals the minimum number written on the cards in the deck, then he places the card away. Otherwise, he puts it under the deck and takes the next card from the top, and so on. The process ends as soon as there are no cards in the deck. You can assume that Vasily always knows the minimum number written on some card in the remaining deck, but doesn't know where this card (or these cards) is.
You are to determine the total number of times Vasily takes the top card from the deck.
Input
The first line contains single integer n (1 β€ n β€ 100 000) β the number of cards in the deck.
The second line contains a sequence of n integers a1, a2, ..., an (1 β€ ai β€ 100 000), where ai is the number written on the i-th from top card in the deck.
Output
Print the total number of times Vasily takes the top card from the deck.
Examples
Input
4
6 3 1 2
Output
7
Input
1
1000
Output
1
Input
7
3 3 3 3 3 3 3
Output
7
Note
In the first example Vasily at first looks at the card with number 6 on it, puts it under the deck, then on the card with number 3, puts it under the deck, and then on the card with number 1. He places away the card with 1, because the number written on it is the minimum among the remaining cards. After that the cards from top to bottom are [2, 6, 3]. Then Vasily looks at the top card with number 2 and puts it away. After that the cards from top to bottom are [6, 3]. Then Vasily looks at card 6, puts it under the deck, then at card 3 and puts it away. Then there is only one card with number 6 on it, and Vasily looks at it and puts it away. Thus, in total Vasily looks at 7 cards. | instruction | 0 | 3,021 | 19 | 6,042 |
Tags: data structures, implementation, sortings
Correct Solution:
```
def main():
input()
numbers = tuple(map(int, input().split()))
d = []
for i in range(len(numbers)):
while len(d) <= numbers[i]:
d.append([])
d[numbers[i]].append(i)
dd = [[]]
for line in d:
if line:
dd.append(line)
d = dd
answer = [None] * len(numbers)
for item in d[1]:
answer[item] = 1
for i in range(1, len(d) - 1):
left_maxes = [0]
right_maxes = [0]
for j in range(len(d[i])):
left_maxes.append(max(left_maxes[-1], answer[d[i][j]]))
right_maxes.append(max(right_maxes[-1],
answer[d[i][len(d[i]) - j - 1]]))
left_amount = 0
for j in range(len(d[i+1])):
while left_amount < len(d[i]) and d[i][left_amount] < d[i+1][j]:
left_amount += 1
answer[d[i+1][j]] = max(left_maxes[left_amount],
right_maxes[len(d[i]) - left_amount] + 1)
res = 0
for ans in answer:
res += ans
print(res)
if __name__ == '__main__':
main()
``` | output | 1 | 3,021 | 19 | 6,043 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasily has a deck of cards consisting of n cards. There is an integer on each of the cards, this integer is between 1 and 100 000, inclusive. It is possible that some cards have the same integers on them.
Vasily decided to sort the cards. To do this, he repeatedly takes the top card from the deck, and if the number on it equals the minimum number written on the cards in the deck, then he places the card away. Otherwise, he puts it under the deck and takes the next card from the top, and so on. The process ends as soon as there are no cards in the deck. You can assume that Vasily always knows the minimum number written on some card in the remaining deck, but doesn't know where this card (or these cards) is.
You are to determine the total number of times Vasily takes the top card from the deck.
Input
The first line contains single integer n (1 β€ n β€ 100 000) β the number of cards in the deck.
The second line contains a sequence of n integers a1, a2, ..., an (1 β€ ai β€ 100 000), where ai is the number written on the i-th from top card in the deck.
Output
Print the total number of times Vasily takes the top card from the deck.
Examples
Input
4
6 3 1 2
Output
7
Input
1
1000
Output
1
Input
7
3 3 3 3 3 3 3
Output
7
Note
In the first example Vasily at first looks at the card with number 6 on it, puts it under the deck, then on the card with number 3, puts it under the deck, and then on the card with number 1. He places away the card with 1, because the number written on it is the minimum among the remaining cards. After that the cards from top to bottom are [2, 6, 3]. Then Vasily looks at the top card with number 2 and puts it away. After that the cards from top to bottom are [6, 3]. Then Vasily looks at card 6, puts it under the deck, then at card 3 and puts it away. Then there is only one card with number 6 on it, and Vasily looks at it and puts it away. Thus, in total Vasily looks at 7 cards. | instruction | 0 | 3,022 | 19 | 6,044 |
Tags: data structures, implementation, sortings
Correct Solution:
```
from collections import deque
import heapq
n = int(input())
cards_help = list(map(int, input().split()))
cards = [ (cards_help[i],-1*i) for i in range(n) ]
heapq.heapify(cards)
draws = 0
removed = 0
while cards:
prev = -1
new_removals = 0
current = cards[0]
while cards and -1*current[1] > prev:
new_removals += 1
heapq.heappop(cards)
temp_prev = -1*current[1]
while cards and cards[0][0] == current[0] and -1*cards[0][1] > prev:
current = cards[0]
heapq.heappop(cards)
new_removals += 1
prev = temp_prev
current = cards[0] if cards else 0
draws += n - removed
removed += new_removals
print(draws)
# Made By Mostafa_Khaled
``` | output | 1 | 3,022 | 19 | 6,045 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasily has a deck of cards consisting of n cards. There is an integer on each of the cards, this integer is between 1 and 100 000, inclusive. It is possible that some cards have the same integers on them.
Vasily decided to sort the cards. To do this, he repeatedly takes the top card from the deck, and if the number on it equals the minimum number written on the cards in the deck, then he places the card away. Otherwise, he puts it under the deck and takes the next card from the top, and so on. The process ends as soon as there are no cards in the deck. You can assume that Vasily always knows the minimum number written on some card in the remaining deck, but doesn't know where this card (or these cards) is.
You are to determine the total number of times Vasily takes the top card from the deck.
Input
The first line contains single integer n (1 β€ n β€ 100 000) β the number of cards in the deck.
The second line contains a sequence of n integers a1, a2, ..., an (1 β€ ai β€ 100 000), where ai is the number written on the i-th from top card in the deck.
Output
Print the total number of times Vasily takes the top card from the deck.
Examples
Input
4
6 3 1 2
Output
7
Input
1
1000
Output
1
Input
7
3 3 3 3 3 3 3
Output
7
Note
In the first example Vasily at first looks at the card with number 6 on it, puts it under the deck, then on the card with number 3, puts it under the deck, and then on the card with number 1. He places away the card with 1, because the number written on it is the minimum among the remaining cards. After that the cards from top to bottom are [2, 6, 3]. Then Vasily looks at the top card with number 2 and puts it away. After that the cards from top to bottom are [6, 3]. Then Vasily looks at card 6, puts it under the deck, then at card 3 and puts it away. Then there is only one card with number 6 on it, and Vasily looks at it and puts it away. Thus, in total Vasily looks at 7 cards. | instruction | 0 | 3,023 | 19 | 6,046 |
Tags: data structures, implementation, sortings
Correct Solution:
```
def solve(arr):
b = list(enumerate(arr))
b.sort(key=lambda x: (x[1]))
res = 0
prev_right = -1
prev_level = -1
cur_level = 1
cur_value = -1
cur_right = -1
for i, v in b:
if v > cur_value:
prev_level = cur_level
prev_right = cur_right
cur_value = v
cur_right = i
if i < prev_right:
cur_level = prev_level + 1
res += cur_level
else:
if i < prev_right:
res += prev_level + 1
if cur_level != prev_level + 1:
cur_level = prev_level + 1
cur_right = i
cur_right = max(cur_right, i)
else:
res += prev_level
if cur_level == prev_level:
cur_right = max(cur_right, i)
return res
n = int(input())
a = [int(x) for x in input().strip().split()]
print(solve(a))
``` | output | 1 | 3,023 | 19 | 6,047 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasily has a deck of cards consisting of n cards. There is an integer on each of the cards, this integer is between 1 and 100 000, inclusive. It is possible that some cards have the same integers on them.
Vasily decided to sort the cards. To do this, he repeatedly takes the top card from the deck, and if the number on it equals the minimum number written on the cards in the deck, then he places the card away. Otherwise, he puts it under the deck and takes the next card from the top, and so on. The process ends as soon as there are no cards in the deck. You can assume that Vasily always knows the minimum number written on some card in the remaining deck, but doesn't know where this card (or these cards) is.
You are to determine the total number of times Vasily takes the top card from the deck.
Input
The first line contains single integer n (1 β€ n β€ 100 000) β the number of cards in the deck.
The second line contains a sequence of n integers a1, a2, ..., an (1 β€ ai β€ 100 000), where ai is the number written on the i-th from top card in the deck.
Output
Print the total number of times Vasily takes the top card from the deck.
Examples
Input
4
6 3 1 2
Output
7
Input
1
1000
Output
1
Input
7
3 3 3 3 3 3 3
Output
7
Note
In the first example Vasily at first looks at the card with number 6 on it, puts it under the deck, then on the card with number 3, puts it under the deck, and then on the card with number 1. He places away the card with 1, because the number written on it is the minimum among the remaining cards. After that the cards from top to bottom are [2, 6, 3]. Then Vasily looks at the top card with number 2 and puts it away. After that the cards from top to bottom are [6, 3]. Then Vasily looks at card 6, puts it under the deck, then at card 3 and puts it away. Then there is only one card with number 6 on it, and Vasily looks at it and puts it away. Thus, in total Vasily looks at 7 cards. | instruction | 0 | 3,024 | 19 | 6,048 |
Tags: data structures, implementation, sortings
Correct Solution:
```
n = int(input())
s = list(map(int,input().split(' ')))
a = []
for i in range(max(s)):
a.append([])
for i in range(len(s)):
a[s[i]-1].append(i)
a = list(filter(lambda x: x != [], a))
if len(a) > 1:
for i in range(1,len(a)):
if len(a[i]) > 1:
s = a[i-1][-1]
if s > a[i][0] and s < a[i][-1]:
for j in range(1,len(a[i])):
if s < a[i][j]:
a[i] = a[i][j:] + a[i][:j]
break
t = []
for i in a:
t += i
c = 0
x = t[0] + 1
i = n-1
while i > 0:
if t[i] < t[i-1]:
k = t[i] - t[i-1] + n
else:
k = t[i] - t[i-1]
c += k
x -= c//n
i -= 1
print(c+x)
``` | output | 1 | 3,024 | 19 | 6,049 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasily has a deck of cards consisting of n cards. There is an integer on each of the cards, this integer is between 1 and 100 000, inclusive. It is possible that some cards have the same integers on them.
Vasily decided to sort the cards. To do this, he repeatedly takes the top card from the deck, and if the number on it equals the minimum number written on the cards in the deck, then he places the card away. Otherwise, he puts it under the deck and takes the next card from the top, and so on. The process ends as soon as there are no cards in the deck. You can assume that Vasily always knows the minimum number written on some card in the remaining deck, but doesn't know where this card (or these cards) is.
You are to determine the total number of times Vasily takes the top card from the deck.
Input
The first line contains single integer n (1 β€ n β€ 100 000) β the number of cards in the deck.
The second line contains a sequence of n integers a1, a2, ..., an (1 β€ ai β€ 100 000), where ai is the number written on the i-th from top card in the deck.
Output
Print the total number of times Vasily takes the top card from the deck.
Examples
Input
4
6 3 1 2
Output
7
Input
1
1000
Output
1
Input
7
3 3 3 3 3 3 3
Output
7
Note
In the first example Vasily at first looks at the card with number 6 on it, puts it under the deck, then on the card with number 3, puts it under the deck, and then on the card with number 1. He places away the card with 1, because the number written on it is the minimum among the remaining cards. After that the cards from top to bottom are [2, 6, 3]. Then Vasily looks at the top card with number 2 and puts it away. After that the cards from top to bottom are [6, 3]. Then Vasily looks at card 6, puts it under the deck, then at card 3 and puts it away. Then there is only one card with number 6 on it, and Vasily looks at it and puts it away. Thus, in total Vasily looks at 7 cards. | instruction | 0 | 3,025 | 19 | 6,050 |
Tags: data structures, implementation, sortings
Correct Solution:
```
from bisect import bisect_left
def read():
return [int(x) for x in input().split()]
n = read()
a = read()
vec = [list() for i in range(max(a)+1)]
for i in range(len(a)):
vec[a[i]].append(i)
def solve():
ans =0
dis = 1
p = 0
i=0
while i <len(vec):
if len(vec[i]):
pos = bisect_left(vec[i],p)
ans += (len(vec[i]) - pos)*dis
p = vec[i][len(vec[i])-1]
# print(i,pos,dis,ans,p)
# print(vec[i])
del vec[i][pos:len(vec[i])]
if len(vec[i]):
p = 0
dis+=1
i-=1
i+=1
return ans
print(solve())
``` | output | 1 | 3,025 | 19 | 6,051 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasily has a deck of cards consisting of n cards. There is an integer on each of the cards, this integer is between 1 and 100 000, inclusive. It is possible that some cards have the same integers on them.
Vasily decided to sort the cards. To do this, he repeatedly takes the top card from the deck, and if the number on it equals the minimum number written on the cards in the deck, then he places the card away. Otherwise, he puts it under the deck and takes the next card from the top, and so on. The process ends as soon as there are no cards in the deck. You can assume that Vasily always knows the minimum number written on some card in the remaining deck, but doesn't know where this card (or these cards) is.
You are to determine the total number of times Vasily takes the top card from the deck.
Input
The first line contains single integer n (1 β€ n β€ 100 000) β the number of cards in the deck.
The second line contains a sequence of n integers a1, a2, ..., an (1 β€ ai β€ 100 000), where ai is the number written on the i-th from top card in the deck.
Output
Print the total number of times Vasily takes the top card from the deck.
Examples
Input
4
6 3 1 2
Output
7
Input
1
1000
Output
1
Input
7
3 3 3 3 3 3 3
Output
7
Note
In the first example Vasily at first looks at the card with number 6 on it, puts it under the deck, then on the card with number 3, puts it under the deck, and then on the card with number 1. He places away the card with 1, because the number written on it is the minimum among the remaining cards. After that the cards from top to bottom are [2, 6, 3]. Then Vasily looks at the top card with number 2 and puts it away. After that the cards from top to bottom are [6, 3]. Then Vasily looks at card 6, puts it under the deck, then at card 3 and puts it away. Then there is only one card with number 6 on it, and Vasily looks at it and puts it away. Thus, in total Vasily looks at 7 cards. | instruction | 0 | 3,026 | 19 | 6,052 |
Tags: data structures, implementation, sortings
Correct Solution:
```
# -*- coding: utf-8 -*-
import sys
# fout = open("output.txt", "w")
fin = sys.stdin
# fin = open("input.txt", "r")
fout = sys.stdout
n = int(fin.readline())
a = list(map(int, fin.readline().split()))
def solution(n, a):
sorted_arr = [(i, elem) for i, elem in enumerate(a)]
sorted_arr.sort(key=lambda x: (x[1], x[0]))
sorted_indexes = [x[0] for x in sorted_arr]
cnt = 0
current_n = n
prev_index = sorted_indexes[0]
prev_elem = sorted_arr[0][1]
cur_len = 1
i = 1
while i < n:
cur_index = sorted_indexes[i]
cur_elem = sorted_arr[i][1]
if prev_index < cur_index:
cur_len += 1
prev_index = sorted_indexes[i]
prev_elem = sorted_arr[i][1]
elif i+1<n and cur_elem == sorted_arr[i+1][1]: # Π·Π΄Π΅ΡΡ ΠΊΠΎΡΡΠΊ
penalty = 1
last_penalty_ind = sorted_indexes[i]
while i+1 < n and sorted_arr[i+1][1] == cur_elem:
if sorted_arr[i+1][0] >= prev_index:
cur_len += 1
else:
penalty += 1
last_penalty_ind = sorted_indexes[i+1]
i += 1
cnt += current_n
current_n -= cur_len
cur_len = penalty
prev_elem = cur_elem
prev_index = last_penalty_ind
else:
cnt += current_n
current_n -= cur_len
cur_len = 1
prev_index = sorted_indexes[i]
prev_elem = sorted_arr[i][1]
i += 1
cnt += current_n
return cnt
cnt = solution(n, a)
fout.write(str(cnt))
fout.close()
``` | output | 1 | 3,026 | 19 | 6,053 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasily has a deck of cards consisting of n cards. There is an integer on each of the cards, this integer is between 1 and 100 000, inclusive. It is possible that some cards have the same integers on them.
Vasily decided to sort the cards. To do this, he repeatedly takes the top card from the deck, and if the number on it equals the minimum number written on the cards in the deck, then he places the card away. Otherwise, he puts it under the deck and takes the next card from the top, and so on. The process ends as soon as there are no cards in the deck. You can assume that Vasily always knows the minimum number written on some card in the remaining deck, but doesn't know where this card (or these cards) is.
You are to determine the total number of times Vasily takes the top card from the deck.
Input
The first line contains single integer n (1 β€ n β€ 100 000) β the number of cards in the deck.
The second line contains a sequence of n integers a1, a2, ..., an (1 β€ ai β€ 100 000), where ai is the number written on the i-th from top card in the deck.
Output
Print the total number of times Vasily takes the top card from the deck.
Examples
Input
4
6 3 1 2
Output
7
Input
1
1000
Output
1
Input
7
3 3 3 3 3 3 3
Output
7
Note
In the first example Vasily at first looks at the card with number 6 on it, puts it under the deck, then on the card with number 3, puts it under the deck, and then on the card with number 1. He places away the card with 1, because the number written on it is the minimum among the remaining cards. After that the cards from top to bottom are [2, 6, 3]. Then Vasily looks at the top card with number 2 and puts it away. After that the cards from top to bottom are [6, 3]. Then Vasily looks at card 6, puts it under the deck, then at card 3 and puts it away. Then there is only one card with number 6 on it, and Vasily looks at it and puts it away. Thus, in total Vasily looks at 7 cards.
Submitted Solution:
```
#input()
#arr = [int(x) for x in input().split()]
arr = [826 ,142 ,89 ,337 ,897, 891 ,1004, 704 ,281 ,644 ,910 ,852, 147, 193, 289, 384 ,625, 695, 416, 944, 162, 939, 164 ,1047, 359, 114, 499 ,99 ,713 ,300, 268, 316, 256, 404, 852, 496, 373 ,322, 716 ,202, 689 ,857, 936, 806, 556 ,153, 137 ,863 ,1047 ,678, 564 ,474, 282, 135, 610, 176, 855, 360, 814, 144, 77, 112, 354, 154]
arr = list(reversed(arr))
out = 0
sorted_arr =[]
while len(arr) != 0:
minimal = min(arr)
curr = arr.pop()
if minimal == curr:
sorted_arr.append(curr)
else:
arr.insert(0, curr)
out += 1
print(out)
print(sorted_arr)
``` | instruction | 0 | 3,027 | 19 | 6,054 |
No | output | 1 | 3,027 | 19 | 6,055 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasily has a deck of cards consisting of n cards. There is an integer on each of the cards, this integer is between 1 and 100 000, inclusive. It is possible that some cards have the same integers on them.
Vasily decided to sort the cards. To do this, he repeatedly takes the top card from the deck, and if the number on it equals the minimum number written on the cards in the deck, then he places the card away. Otherwise, he puts it under the deck and takes the next card from the top, and so on. The process ends as soon as there are no cards in the deck. You can assume that Vasily always knows the minimum number written on some card in the remaining deck, but doesn't know where this card (or these cards) is.
You are to determine the total number of times Vasily takes the top card from the deck.
Input
The first line contains single integer n (1 β€ n β€ 100 000) β the number of cards in the deck.
The second line contains a sequence of n integers a1, a2, ..., an (1 β€ ai β€ 100 000), where ai is the number written on the i-th from top card in the deck.
Output
Print the total number of times Vasily takes the top card from the deck.
Examples
Input
4
6 3 1 2
Output
7
Input
1
1000
Output
1
Input
7
3 3 3 3 3 3 3
Output
7
Note
In the first example Vasily at first looks at the card with number 6 on it, puts it under the deck, then on the card with number 3, puts it under the deck, and then on the card with number 1. He places away the card with 1, because the number written on it is the minimum among the remaining cards. After that the cards from top to bottom are [2, 6, 3]. Then Vasily looks at the top card with number 2 and puts it away. After that the cards from top to bottom are [6, 3]. Then Vasily looks at card 6, puts it under the deck, then at card 3 and puts it away. Then there is only one card with number 6 on it, and Vasily looks at it and puts it away. Thus, in total Vasily looks at 7 cards.
Submitted Solution:
```
n = int(input())
s = list(map(int,input().split(' ')))
a = sorted(range(len(s)), key=lambda k: s[k])
c = 0
x = a[0] + 1
i = n-1
while i > 0:
if a[i] < a[i-1]:
k = a[i] - a[i-1] + n
else:
k = a[i] - a[i-1]
c += k
x -= c//n
i -= 1
print(c+x)
``` | instruction | 0 | 3,028 | 19 | 6,056 |
No | output | 1 | 3,028 | 19 | 6,057 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasily has a deck of cards consisting of n cards. There is an integer on each of the cards, this integer is between 1 and 100 000, inclusive. It is possible that some cards have the same integers on them.
Vasily decided to sort the cards. To do this, he repeatedly takes the top card from the deck, and if the number on it equals the minimum number written on the cards in the deck, then he places the card away. Otherwise, he puts it under the deck and takes the next card from the top, and so on. The process ends as soon as there are no cards in the deck. You can assume that Vasily always knows the minimum number written on some card in the remaining deck, but doesn't know where this card (or these cards) is.
You are to determine the total number of times Vasily takes the top card from the deck.
Input
The first line contains single integer n (1 β€ n β€ 100 000) β the number of cards in the deck.
The second line contains a sequence of n integers a1, a2, ..., an (1 β€ ai β€ 100 000), where ai is the number written on the i-th from top card in the deck.
Output
Print the total number of times Vasily takes the top card from the deck.
Examples
Input
4
6 3 1 2
Output
7
Input
1
1000
Output
1
Input
7
3 3 3 3 3 3 3
Output
7
Note
In the first example Vasily at first looks at the card with number 6 on it, puts it under the deck, then on the card with number 3, puts it under the deck, and then on the card with number 1. He places away the card with 1, because the number written on it is the minimum among the remaining cards. After that the cards from top to bottom are [2, 6, 3]. Then Vasily looks at the top card with number 2 and puts it away. After that the cards from top to bottom are [6, 3]. Then Vasily looks at card 6, puts it under the deck, then at card 3 and puts it away. Then there is only one card with number 6 on it, and Vasily looks at it and puts it away. Thus, in total Vasily looks at 7 cards.
Submitted Solution:
```
# -*- coding: utf-8 -*-
import sys
# fout = open("output.txt", "w")
fin = sys.stdin
# fin = open("input.txt", "r")
fout = sys.stdout
n = int(fin.readline())
a = list(map(int, fin.readline().split()))
def solution(n, a):
sorted_arr = [(i, elem) for i, elem in enumerate(a)]
sorted_arr.sort(key=lambda x: (x[1], x[0]))
sorted_indexes = [x[0] for x in sorted_arr]
cnt = 0
current_n = n
prev = sorted_indexes[0]
cur_len = 1
for i in range(1, n):
if prev <= sorted_indexes[i]:
cur_len += 1
prev = sorted_indexes[i]
else:
cnt += current_n
current_n -= cur_len
cur_len = 1
prev = sorted_indexes[i]
cnt += current_n
return cnt
cnt = solution(n, a)
fout.write(str(cnt))
fout.close()
``` | instruction | 0 | 3,029 | 19 | 6,058 |
No | output | 1 | 3,029 | 19 | 6,059 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasily has a deck of cards consisting of n cards. There is an integer on each of the cards, this integer is between 1 and 100 000, inclusive. It is possible that some cards have the same integers on them.
Vasily decided to sort the cards. To do this, he repeatedly takes the top card from the deck, and if the number on it equals the minimum number written on the cards in the deck, then he places the card away. Otherwise, he puts it under the deck and takes the next card from the top, and so on. The process ends as soon as there are no cards in the deck. You can assume that Vasily always knows the minimum number written on some card in the remaining deck, but doesn't know where this card (or these cards) is.
You are to determine the total number of times Vasily takes the top card from the deck.
Input
The first line contains single integer n (1 β€ n β€ 100 000) β the number of cards in the deck.
The second line contains a sequence of n integers a1, a2, ..., an (1 β€ ai β€ 100 000), where ai is the number written on the i-th from top card in the deck.
Output
Print the total number of times Vasily takes the top card from the deck.
Examples
Input
4
6 3 1 2
Output
7
Input
1
1000
Output
1
Input
7
3 3 3 3 3 3 3
Output
7
Note
In the first example Vasily at first looks at the card with number 6 on it, puts it under the deck, then on the card with number 3, puts it under the deck, and then on the card with number 1. He places away the card with 1, because the number written on it is the minimum among the remaining cards. After that the cards from top to bottom are [2, 6, 3]. Then Vasily looks at the top card with number 2 and puts it away. After that the cards from top to bottom are [6, 3]. Then Vasily looks at card 6, puts it under the deck, then at card 3 and puts it away. Then there is only one card with number 6 on it, and Vasily looks at it and puts it away. Thus, in total Vasily looks at 7 cards.
Submitted Solution:
```
def lowestPos(a):
lowestIndex = 0
lowest = a[lowestIndex]
for i in range(len(a)):
if a[i] < lowest:
lowestIndex = i
lowest = a[lowestIndex]
return lowestIndex
def moveToBack(a, num):
for _ in range(num):
a.append(a.pop(0))
return a
if __name__ == "__main__":
input()
a = input().split()
counter = 0
while (len(a) > 0):
position = lowestPos(a)
a = moveToBack(a, position)
a.pop(0)
counter += 1 + position
print(counter)
``` | instruction | 0 | 3,030 | 19 | 6,060 |
No | output | 1 | 3,030 | 19 | 6,061 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently Vasya decided to improve his pistol shooting skills. Today his coach offered him the following exercise. He placed n cans in a row on a table. Cans are numbered from left to right from 1 to n. Vasya has to knock down each can exactly once to finish the exercise. He is allowed to choose the order in which he will knock the cans down.
Vasya knows that the durability of the i-th can is a_i. It means that if Vasya has already knocked x cans down and is now about to start shooting the i-th one, he will need (a_i β
x + 1) shots to knock it down. You can assume that if Vasya starts shooting the i-th can, he will be shooting it until he knocks it down.
Your task is to choose such an order of shooting so that the number of shots required to knock each of the n given cans down exactly once is minimum possible.
Input
The first line of the input contains one integer n (2 β€ n β€ 1 000) β the number of cans.
The second line of the input contains the sequence a_1, a_2, ..., a_n (1 β€ a_i β€ 1 000), where a_i is the durability of the i-th can.
Output
In the first line print the minimum number of shots required to knock each of the n given cans down exactly once.
In the second line print the sequence consisting of n distinct integers from 1 to n β the order of indices of cans that minimizes the number of shots required. If there are several answers, you can print any of them.
Examples
Input
3
20 10 20
Output
43
1 3 2
Input
4
10 10 10 10
Output
64
2 1 4 3
Input
6
5 4 5 4 4 5
Output
69
6 1 3 5 2 4
Input
2
1 4
Output
3
2 1
Note
In the first example Vasya can start shooting from the first can. He knocks it down with the first shot because he haven't knocked any other cans down before. After that he has to shoot the third can. To knock it down he shoots 20 β
1 + 1 = 21 times. After that only second can remains. To knock it down Vasya shoots 10 β
2 + 1 = 21 times. So the total number of shots is 1 + 21 + 21 = 43.
In the second example the order of shooting does not matter because all cans have the same durability. | instruction | 0 | 3,424 | 19 | 6,848 |
Tags: greedy, implementation, sortings
Correct Solution:
```
n = int(input())
l = list(map(int, input().split()))
ind = {}
i = 0
s = 0
for j in l:
if j in ind.keys():
ind[j].append(str(i + 1))
else:
ind[j] = [str(i + 1)]
i += 1
l.sort(key = lambda x : -x)
for x in range(len(l)):
s += l[x] * x + 1
print(s)
d = list(ind.items())
d.sort(key = lambda t : -t[0])
for i in d:
print(' '.join(i[1]), end = ' ')
``` | output | 1 | 3,424 | 19 | 6,849 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently Vasya decided to improve his pistol shooting skills. Today his coach offered him the following exercise. He placed n cans in a row on a table. Cans are numbered from left to right from 1 to n. Vasya has to knock down each can exactly once to finish the exercise. He is allowed to choose the order in which he will knock the cans down.
Vasya knows that the durability of the i-th can is a_i. It means that if Vasya has already knocked x cans down and is now about to start shooting the i-th one, he will need (a_i β
x + 1) shots to knock it down. You can assume that if Vasya starts shooting the i-th can, he will be shooting it until he knocks it down.
Your task is to choose such an order of shooting so that the number of shots required to knock each of the n given cans down exactly once is minimum possible.
Input
The first line of the input contains one integer n (2 β€ n β€ 1 000) β the number of cans.
The second line of the input contains the sequence a_1, a_2, ..., a_n (1 β€ a_i β€ 1 000), where a_i is the durability of the i-th can.
Output
In the first line print the minimum number of shots required to knock each of the n given cans down exactly once.
In the second line print the sequence consisting of n distinct integers from 1 to n β the order of indices of cans that minimizes the number of shots required. If there are several answers, you can print any of them.
Examples
Input
3
20 10 20
Output
43
1 3 2
Input
4
10 10 10 10
Output
64
2 1 4 3
Input
6
5 4 5 4 4 5
Output
69
6 1 3 5 2 4
Input
2
1 4
Output
3
2 1
Note
In the first example Vasya can start shooting from the first can. He knocks it down with the first shot because he haven't knocked any other cans down before. After that he has to shoot the third can. To knock it down he shoots 20 β
1 + 1 = 21 times. After that only second can remains. To knock it down Vasya shoots 10 β
2 + 1 = 21 times. So the total number of shots is 1 + 21 + 21 = 43.
In the second example the order of shooting does not matter because all cans have the same durability. | instruction | 0 | 3,425 | 19 | 6,850 |
Tags: greedy, implementation, sortings
Correct Solution:
```
n = int(input())
a = [(int(el), i + 1) for i, el in enumerate(input().split())]
a = sorted(a, reverse=True)
shots = 0
for i, (el, _) in enumerate(a):
shots += i * el + 1
print(shots)
print(*(i for _, i in a))
``` | output | 1 | 3,425 | 19 | 6,851 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently Vasya decided to improve his pistol shooting skills. Today his coach offered him the following exercise. He placed n cans in a row on a table. Cans are numbered from left to right from 1 to n. Vasya has to knock down each can exactly once to finish the exercise. He is allowed to choose the order in which he will knock the cans down.
Vasya knows that the durability of the i-th can is a_i. It means that if Vasya has already knocked x cans down and is now about to start shooting the i-th one, he will need (a_i β
x + 1) shots to knock it down. You can assume that if Vasya starts shooting the i-th can, he will be shooting it until he knocks it down.
Your task is to choose such an order of shooting so that the number of shots required to knock each of the n given cans down exactly once is minimum possible.
Input
The first line of the input contains one integer n (2 β€ n β€ 1 000) β the number of cans.
The second line of the input contains the sequence a_1, a_2, ..., a_n (1 β€ a_i β€ 1 000), where a_i is the durability of the i-th can.
Output
In the first line print the minimum number of shots required to knock each of the n given cans down exactly once.
In the second line print the sequence consisting of n distinct integers from 1 to n β the order of indices of cans that minimizes the number of shots required. If there are several answers, you can print any of them.
Examples
Input
3
20 10 20
Output
43
1 3 2
Input
4
10 10 10 10
Output
64
2 1 4 3
Input
6
5 4 5 4 4 5
Output
69
6 1 3 5 2 4
Input
2
1 4
Output
3
2 1
Note
In the first example Vasya can start shooting from the first can. He knocks it down with the first shot because he haven't knocked any other cans down before. After that he has to shoot the third can. To knock it down he shoots 20 β
1 + 1 = 21 times. After that only second can remains. To knock it down Vasya shoots 10 β
2 + 1 = 21 times. So the total number of shots is 1 + 21 + 21 = 43.
In the second example the order of shooting does not matter because all cans have the same durability. | instruction | 0 | 3,426 | 19 | 6,852 |
Tags: greedy, implementation, sortings
Correct Solution:
```
n = int(input())
a = list(map(int, input().split()))
r = []
ans = 0
for i in range(n):
pos = -1
for j in range(n):
if (pos == -1 or a[j] > a[pos]): pos = j
r.append(pos + 1)
ans += i * a[pos] + 1
a[pos] = 0
print(ans)
print(*r)
``` | output | 1 | 3,426 | 19 | 6,853 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently Vasya decided to improve his pistol shooting skills. Today his coach offered him the following exercise. He placed n cans in a row on a table. Cans are numbered from left to right from 1 to n. Vasya has to knock down each can exactly once to finish the exercise. He is allowed to choose the order in which he will knock the cans down.
Vasya knows that the durability of the i-th can is a_i. It means that if Vasya has already knocked x cans down and is now about to start shooting the i-th one, he will need (a_i β
x + 1) shots to knock it down. You can assume that if Vasya starts shooting the i-th can, he will be shooting it until he knocks it down.
Your task is to choose such an order of shooting so that the number of shots required to knock each of the n given cans down exactly once is minimum possible.
Input
The first line of the input contains one integer n (2 β€ n β€ 1 000) β the number of cans.
The second line of the input contains the sequence a_1, a_2, ..., a_n (1 β€ a_i β€ 1 000), where a_i is the durability of the i-th can.
Output
In the first line print the minimum number of shots required to knock each of the n given cans down exactly once.
In the second line print the sequence consisting of n distinct integers from 1 to n β the order of indices of cans that minimizes the number of shots required. If there are several answers, you can print any of them.
Examples
Input
3
20 10 20
Output
43
1 3 2
Input
4
10 10 10 10
Output
64
2 1 4 3
Input
6
5 4 5 4 4 5
Output
69
6 1 3 5 2 4
Input
2
1 4
Output
3
2 1
Note
In the first example Vasya can start shooting from the first can. He knocks it down with the first shot because he haven't knocked any other cans down before. After that he has to shoot the third can. To knock it down he shoots 20 β
1 + 1 = 21 times. After that only second can remains. To knock it down Vasya shoots 10 β
2 + 1 = 21 times. So the total number of shots is 1 + 21 + 21 = 43.
In the second example the order of shooting does not matter because all cans have the same durability. | instruction | 0 | 3,427 | 19 | 6,854 |
Tags: greedy, implementation, sortings
Correct Solution:
```
n=int(input())
x=list(map(int,input().split()))
y=[]
for i in range(n) :
y.append([x[i],i+1])
y=sorted(y);s=0;temp=[]
y=list(reversed(y))
for i in range(n) :
s=s+(y[i][0]*i+1)
temp.append(y[i][1])
print(s)
for c in temp :
print(c,end=' ')
``` | output | 1 | 3,427 | 19 | 6,855 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently Vasya decided to improve his pistol shooting skills. Today his coach offered him the following exercise. He placed n cans in a row on a table. Cans are numbered from left to right from 1 to n. Vasya has to knock down each can exactly once to finish the exercise. He is allowed to choose the order in which he will knock the cans down.
Vasya knows that the durability of the i-th can is a_i. It means that if Vasya has already knocked x cans down and is now about to start shooting the i-th one, he will need (a_i β
x + 1) shots to knock it down. You can assume that if Vasya starts shooting the i-th can, he will be shooting it until he knocks it down.
Your task is to choose such an order of shooting so that the number of shots required to knock each of the n given cans down exactly once is minimum possible.
Input
The first line of the input contains one integer n (2 β€ n β€ 1 000) β the number of cans.
The second line of the input contains the sequence a_1, a_2, ..., a_n (1 β€ a_i β€ 1 000), where a_i is the durability of the i-th can.
Output
In the first line print the minimum number of shots required to knock each of the n given cans down exactly once.
In the second line print the sequence consisting of n distinct integers from 1 to n β the order of indices of cans that minimizes the number of shots required. If there are several answers, you can print any of them.
Examples
Input
3
20 10 20
Output
43
1 3 2
Input
4
10 10 10 10
Output
64
2 1 4 3
Input
6
5 4 5 4 4 5
Output
69
6 1 3 5 2 4
Input
2
1 4
Output
3
2 1
Note
In the first example Vasya can start shooting from the first can. He knocks it down with the first shot because he haven't knocked any other cans down before. After that he has to shoot the third can. To knock it down he shoots 20 β
1 + 1 = 21 times. After that only second can remains. To knock it down Vasya shoots 10 β
2 + 1 = 21 times. So the total number of shots is 1 + 21 + 21 = 43.
In the second example the order of shooting does not matter because all cans have the same durability. | instruction | 0 | 3,428 | 19 | 6,856 |
Tags: greedy, implementation, sortings
Correct Solution:
```
n=int(input())
aa=list(map(int, input().split()))
a=[ [0]*2 for i in range(n)]
for i in range(n):
a[i][0]=aa[i]
a[i][1]=i+1
#for i in range(n):
#for j in range(2):
#print(a[i][j], end=' ')
#print()
a.sort(key= lambda x: x[0])
#for i in range(n):
#for j in range(2):
#print(a[i][j], end=' ')
#print()
k=0
x=0
for i in range(n-1, -1, -1):
k+=a[i][0]*x+1
x+=1
print(k)
for i in range(n-1, -1, -1):
print(a[i][1], end=' ')
``` | output | 1 | 3,428 | 19 | 6,857 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently Vasya decided to improve his pistol shooting skills. Today his coach offered him the following exercise. He placed n cans in a row on a table. Cans are numbered from left to right from 1 to n. Vasya has to knock down each can exactly once to finish the exercise. He is allowed to choose the order in which he will knock the cans down.
Vasya knows that the durability of the i-th can is a_i. It means that if Vasya has already knocked x cans down and is now about to start shooting the i-th one, he will need (a_i β
x + 1) shots to knock it down. You can assume that if Vasya starts shooting the i-th can, he will be shooting it until he knocks it down.
Your task is to choose such an order of shooting so that the number of shots required to knock each of the n given cans down exactly once is minimum possible.
Input
The first line of the input contains one integer n (2 β€ n β€ 1 000) β the number of cans.
The second line of the input contains the sequence a_1, a_2, ..., a_n (1 β€ a_i β€ 1 000), where a_i is the durability of the i-th can.
Output
In the first line print the minimum number of shots required to knock each of the n given cans down exactly once.
In the second line print the sequence consisting of n distinct integers from 1 to n β the order of indices of cans that minimizes the number of shots required. If there are several answers, you can print any of them.
Examples
Input
3
20 10 20
Output
43
1 3 2
Input
4
10 10 10 10
Output
64
2 1 4 3
Input
6
5 4 5 4 4 5
Output
69
6 1 3 5 2 4
Input
2
1 4
Output
3
2 1
Note
In the first example Vasya can start shooting from the first can. He knocks it down with the first shot because he haven't knocked any other cans down before. After that he has to shoot the third can. To knock it down he shoots 20 β
1 + 1 = 21 times. After that only second can remains. To knock it down Vasya shoots 10 β
2 + 1 = 21 times. So the total number of shots is 1 + 21 + 21 = 43.
In the second example the order of shooting does not matter because all cans have the same durability. | instruction | 0 | 3,429 | 19 | 6,858 |
Tags: greedy, implementation, sortings
Correct Solution:
```
n = int(input())
h = list(map(int, input().split()))
s = 0
c = []
i = 0
while i < n:
c.append(h.index(max(h))+1)
s += max(h)*i+1
h[h.index(max(h))] = -100
i+=1
print(s)
i = 0
while i < len(c):
print(c[i], end=' ')
i+=1
``` | output | 1 | 3,429 | 19 | 6,859 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently Vasya decided to improve his pistol shooting skills. Today his coach offered him the following exercise. He placed n cans in a row on a table. Cans are numbered from left to right from 1 to n. Vasya has to knock down each can exactly once to finish the exercise. He is allowed to choose the order in which he will knock the cans down.
Vasya knows that the durability of the i-th can is a_i. It means that if Vasya has already knocked x cans down and is now about to start shooting the i-th one, he will need (a_i β
x + 1) shots to knock it down. You can assume that if Vasya starts shooting the i-th can, he will be shooting it until he knocks it down.
Your task is to choose such an order of shooting so that the number of shots required to knock each of the n given cans down exactly once is minimum possible.
Input
The first line of the input contains one integer n (2 β€ n β€ 1 000) β the number of cans.
The second line of the input contains the sequence a_1, a_2, ..., a_n (1 β€ a_i β€ 1 000), where a_i is the durability of the i-th can.
Output
In the first line print the minimum number of shots required to knock each of the n given cans down exactly once.
In the second line print the sequence consisting of n distinct integers from 1 to n β the order of indices of cans that minimizes the number of shots required. If there are several answers, you can print any of them.
Examples
Input
3
20 10 20
Output
43
1 3 2
Input
4
10 10 10 10
Output
64
2 1 4 3
Input
6
5 4 5 4 4 5
Output
69
6 1 3 5 2 4
Input
2
1 4
Output
3
2 1
Note
In the first example Vasya can start shooting from the first can. He knocks it down with the first shot because he haven't knocked any other cans down before. After that he has to shoot the third can. To knock it down he shoots 20 β
1 + 1 = 21 times. After that only second can remains. To knock it down Vasya shoots 10 β
2 + 1 = 21 times. So the total number of shots is 1 + 21 + 21 = 43.
In the second example the order of shooting does not matter because all cans have the same durability. | instruction | 0 | 3,430 | 19 | 6,860 |
Tags: greedy, implementation, sortings
Correct Solution:
```
n = int(input())
s = map(int,input().split())
s = list(s)
# max(s) - ΡΡΠΎ Π΄ΠΎΡΠΎΠ³Π°Ρ ΠΎΠΏΠ΅ΡΠ°ΡΠΈΡ (O(n)), ΡΠΎΡΠ½ΠΎ ΡΠ°ΠΊ ΠΆΠ΅, ΠΊΠ°ΠΊ ΠΈ s.index(a)
# Π₯ΠΎΡΡ Π΄Π»Ρ ΡΡΠΎΠΉ Π·Π°Π΄Π°ΡΠΈ ΡΡΠΎ Π½Π΅ ΠΏΡΠΈΠ½ΡΠΈΠΏΠΈΠ°Π»ΡΠ½ΠΎ, Π²ΡΠ΅ ΠΆΠ΅ ΠΏΡΠΎΠ³ΡΠ°ΠΌΠΌΡ ΠΌΠΎΠΆΠ½ΠΎ ΡΠΈΠ»ΡΠ½ΠΎ ΡΡΠΊΠΎΡΠΈΡΡ
# Π‘Π΅ΠΉΡΠ°Ρ Π΅Ρ ΡΠ»ΠΎΠΆΠ½ΠΎΡΡΡ ΡΠ°Π²Π½Π° O(n^2), Π° ΠΌΡ ΡΡΠΊΠΎΡΠΈΠΌ Π΄ΠΎ O(n * log(n))
# Π§ΡΠΎΠ±Ρ Π½Π΅ ΠΈΡΠΊΠ°ΡΡ ΠΊΠ°ΠΆΠ΄ΡΠΉ ΡΠ°Π· ΠΌΠ°ΠΊΡΠΈΠΌΡΠΌ, Π²Π½Π°ΡΠ°Π»Π΅ ΠΎΡΡΠΎΡΡΠΈΡΡΠ΅ΠΌ ΡΠΏΠΈΡΠΎΠΊ
# Π’Π°ΠΊ ΠΊΠ°ΠΊ Π½Π°ΠΌ Π½ΡΠΆΠ½ΠΎ ΡΠΎΡΡΠΈΡΠΎΠ²Π°ΡΡ Π½Π΅ ΡΠΎΠ»ΡΠΊΠΎ ΡΠ»Π΅ΠΌΠ΅Π½ΡΡ, Π½ΠΎ ΠΈ ΠΈΡ
ΠΈΠ½Π΄Π΅ΠΊΡΡ, ΠΏΠΎΡΡΡΠΎΠΈΠΌ ΠΏΡΠΎΠΌΠ΅ΠΆΡΡΠΎΡΠ½ΡΠΉ ΡΠΏΠΈΡΠΎΠΊ:
l = [(i, a) for i, a in enumerate(s)]
# ΠΡΡΠΎΡΡΠΈΡΡΠ΅ΠΌ Π΅Π³ΠΎ. ΠΡΠΈ ΡΡΠΎΠΌ ΠΈΡΡ
ΠΎΠ΄Π½ΡΠ΅ ΠΈΠ½Π΄Π΅ΠΊΡΡ ΠΎΡΡΠΎΡΡΠΈΡΡΡΡΡΡ Π²ΠΌΠ΅ΡΡΠ΅ Ρ ΡΠ»Π΅ΠΌΠ΅Π½ΡΠ°ΠΌΠΈ
# Π‘ΠΎΡΡΠΈΡΠΎΠ²ΠΊΠ° ΡΠ°Π±ΠΎΡΠ°Π΅Ρ Π·Π° O(n * log(n)). ΠΡΠΎ ΡΠ°ΠΌΠ°Ρ ΡΠ»ΠΎΠΆΠ½Π°Ρ ΡΠ°ΡΡΡ ΠΏΡΠΎΠ³ΡΠ°ΠΌΠΌΡ.
l = sorted(l, reverse=True, key=lambda x: x[1])
banok_sbito = 0
otvet = 0
poryadok_banok = []
# ΠΡΠΎ ΠΏΡΠΎΡΡΠΎΠΉ ΠΏΡΠΎΡ
ΠΎΠ΄ ΠΏΠΎ ΡΠΈΠΊΠ»Ρ. Π‘Π»ΠΎΠΆΠ½ΠΎΡΡΡ - O(n)
for i, a in l:
otvet += a * banok_sbito + 1
banok_sbito += 1
poryadok_banok.append(i + 1)
print(otvet)
print(' '.join(map(str, poryadok_banok)))
``` | output | 1 | 3,430 | 19 | 6,861 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently Vasya decided to improve his pistol shooting skills. Today his coach offered him the following exercise. He placed n cans in a row on a table. Cans are numbered from left to right from 1 to n. Vasya has to knock down each can exactly once to finish the exercise. He is allowed to choose the order in which he will knock the cans down.
Vasya knows that the durability of the i-th can is a_i. It means that if Vasya has already knocked x cans down and is now about to start shooting the i-th one, he will need (a_i β
x + 1) shots to knock it down. You can assume that if Vasya starts shooting the i-th can, he will be shooting it until he knocks it down.
Your task is to choose such an order of shooting so that the number of shots required to knock each of the n given cans down exactly once is minimum possible.
Input
The first line of the input contains one integer n (2 β€ n β€ 1 000) β the number of cans.
The second line of the input contains the sequence a_1, a_2, ..., a_n (1 β€ a_i β€ 1 000), where a_i is the durability of the i-th can.
Output
In the first line print the minimum number of shots required to knock each of the n given cans down exactly once.
In the second line print the sequence consisting of n distinct integers from 1 to n β the order of indices of cans that minimizes the number of shots required. If there are several answers, you can print any of them.
Examples
Input
3
20 10 20
Output
43
1 3 2
Input
4
10 10 10 10
Output
64
2 1 4 3
Input
6
5 4 5 4 4 5
Output
69
6 1 3 5 2 4
Input
2
1 4
Output
3
2 1
Note
In the first example Vasya can start shooting from the first can. He knocks it down with the first shot because he haven't knocked any other cans down before. After that he has to shoot the third can. To knock it down he shoots 20 β
1 + 1 = 21 times. After that only second can remains. To knock it down Vasya shoots 10 β
2 + 1 = 21 times. So the total number of shots is 1 + 21 + 21 = 43.
In the second example the order of shooting does not matter because all cans have the same durability. | instruction | 0 | 3,431 | 19 | 6,862 |
Tags: greedy, implementation, sortings
Correct Solution:
```
# -*- coding: utf-8 -*-
"""
Created on Wed Jul 29 07:49:14 2020
@author: Harshal
"""
n=int(input())
arr=list(map(int,input().split()))
temp=[(c,i) for i,c in enumerate(arr)]
temp.sort(reverse=True)
score=0
order=[]
for i,can in enumerate(temp):
score+=can[0]*i+1
order.append(can[1]+1)
print(score)
print(*order)
``` | output | 1 | 3,431 | 19 | 6,863 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently Vasya decided to improve his pistol shooting skills. Today his coach offered him the following exercise. He placed n cans in a row on a table. Cans are numbered from left to right from 1 to n. Vasya has to knock down each can exactly once to finish the exercise. He is allowed to choose the order in which he will knock the cans down.
Vasya knows that the durability of the i-th can is a_i. It means that if Vasya has already knocked x cans down and is now about to start shooting the i-th one, he will need (a_i β
x + 1) shots to knock it down. You can assume that if Vasya starts shooting the i-th can, he will be shooting it until he knocks it down.
Your task is to choose such an order of shooting so that the number of shots required to knock each of the n given cans down exactly once is minimum possible.
Input
The first line of the input contains one integer n (2 β€ n β€ 1 000) β the number of cans.
The second line of the input contains the sequence a_1, a_2, ..., a_n (1 β€ a_i β€ 1 000), where a_i is the durability of the i-th can.
Output
In the first line print the minimum number of shots required to knock each of the n given cans down exactly once.
In the second line print the sequence consisting of n distinct integers from 1 to n β the order of indices of cans that minimizes the number of shots required. If there are several answers, you can print any of them.
Examples
Input
3
20 10 20
Output
43
1 3 2
Input
4
10 10 10 10
Output
64
2 1 4 3
Input
6
5 4 5 4 4 5
Output
69
6 1 3 5 2 4
Input
2
1 4
Output
3
2 1
Note
In the first example Vasya can start shooting from the first can. He knocks it down with the first shot because he haven't knocked any other cans down before. After that he has to shoot the third can. To knock it down he shoots 20 β
1 + 1 = 21 times. After that only second can remains. To knock it down Vasya shoots 10 β
2 + 1 = 21 times. So the total number of shots is 1 + 21 + 21 = 43.
In the second example the order of shooting does not matter because all cans have the same durability.
Submitted Solution:
```
n = int(input())
nums = list(map(int, input().strip().split()))
sore = sorted(nums, reverse = True)
alist = []
count = 0
for shin, i in enumerate(sore):
ind = nums.index(i)
count += (shin*nums[ind] + 1)
nums[ind] = None
alist.append(str(ind+1))
print(count)
print(' '.join(alist))
``` | instruction | 0 | 3,432 | 19 | 6,864 |
Yes | output | 1 | 3,432 | 19 | 6,865 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently Vasya decided to improve his pistol shooting skills. Today his coach offered him the following exercise. He placed n cans in a row on a table. Cans are numbered from left to right from 1 to n. Vasya has to knock down each can exactly once to finish the exercise. He is allowed to choose the order in which he will knock the cans down.
Vasya knows that the durability of the i-th can is a_i. It means that if Vasya has already knocked x cans down and is now about to start shooting the i-th one, he will need (a_i β
x + 1) shots to knock it down. You can assume that if Vasya starts shooting the i-th can, he will be shooting it until he knocks it down.
Your task is to choose such an order of shooting so that the number of shots required to knock each of the n given cans down exactly once is minimum possible.
Input
The first line of the input contains one integer n (2 β€ n β€ 1 000) β the number of cans.
The second line of the input contains the sequence a_1, a_2, ..., a_n (1 β€ a_i β€ 1 000), where a_i is the durability of the i-th can.
Output
In the first line print the minimum number of shots required to knock each of the n given cans down exactly once.
In the second line print the sequence consisting of n distinct integers from 1 to n β the order of indices of cans that minimizes the number of shots required. If there are several answers, you can print any of them.
Examples
Input
3
20 10 20
Output
43
1 3 2
Input
4
10 10 10 10
Output
64
2 1 4 3
Input
6
5 4 5 4 4 5
Output
69
6 1 3 5 2 4
Input
2
1 4
Output
3
2 1
Note
In the first example Vasya can start shooting from the first can. He knocks it down with the first shot because he haven't knocked any other cans down before. After that he has to shoot the third can. To knock it down he shoots 20 β
1 + 1 = 21 times. After that only second can remains. To knock it down Vasya shoots 10 β
2 + 1 = 21 times. So the total number of shots is 1 + 21 + 21 = 43.
In the second example the order of shooting does not matter because all cans have the same durability.
Submitted Solution:
```
# your code goes here
n = int(input())
arr = list(map(int,input().split()))
data = []
for i in range(n):
data.append([arr[i],i])
shots = 0
ans = 0
data.sort(key = lambda x:x[0],reverse = True)
for i in range(n):
ans += (shots*data[i][0] + 1)
shots += 1
print(ans)
for i in data:
print(i[1]+1,end = ' ')
``` | instruction | 0 | 3,433 | 19 | 6,866 |
Yes | output | 1 | 3,433 | 19 | 6,867 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently Vasya decided to improve his pistol shooting skills. Today his coach offered him the following exercise. He placed n cans in a row on a table. Cans are numbered from left to right from 1 to n. Vasya has to knock down each can exactly once to finish the exercise. He is allowed to choose the order in which he will knock the cans down.
Vasya knows that the durability of the i-th can is a_i. It means that if Vasya has already knocked x cans down and is now about to start shooting the i-th one, he will need (a_i β
x + 1) shots to knock it down. You can assume that if Vasya starts shooting the i-th can, he will be shooting it until he knocks it down.
Your task is to choose such an order of shooting so that the number of shots required to knock each of the n given cans down exactly once is minimum possible.
Input
The first line of the input contains one integer n (2 β€ n β€ 1 000) β the number of cans.
The second line of the input contains the sequence a_1, a_2, ..., a_n (1 β€ a_i β€ 1 000), where a_i is the durability of the i-th can.
Output
In the first line print the minimum number of shots required to knock each of the n given cans down exactly once.
In the second line print the sequence consisting of n distinct integers from 1 to n β the order of indices of cans that minimizes the number of shots required. If there are several answers, you can print any of them.
Examples
Input
3
20 10 20
Output
43
1 3 2
Input
4
10 10 10 10
Output
64
2 1 4 3
Input
6
5 4 5 4 4 5
Output
69
6 1 3 5 2 4
Input
2
1 4
Output
3
2 1
Note
In the first example Vasya can start shooting from the first can. He knocks it down with the first shot because he haven't knocked any other cans down before. After that he has to shoot the third can. To knock it down he shoots 20 β
1 + 1 = 21 times. After that only second can remains. To knock it down Vasya shoots 10 β
2 + 1 = 21 times. So the total number of shots is 1 + 21 + 21 = 43.
In the second example the order of shooting does not matter because all cans have the same durability.
Submitted Solution:
```
L = int(input())
c = list(map(int, input().split(' ')))
Nc = []
for i, v in enumerate(c):
Nc.append([v, i])
def d(v):
return v[0]
Nc.sort(key=d, reverse=True)
counter = 0
x = 0
ans = ''
for i in Nc:
n= i[0]
counter += n*x+1
ans += str(i[1]+1) + ' '
x +=1
print(counter)
print(ans[:-1])
``` | instruction | 0 | 3,434 | 19 | 6,868 |
Yes | output | 1 | 3,434 | 19 | 6,869 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently Vasya decided to improve his pistol shooting skills. Today his coach offered him the following exercise. He placed n cans in a row on a table. Cans are numbered from left to right from 1 to n. Vasya has to knock down each can exactly once to finish the exercise. He is allowed to choose the order in which he will knock the cans down.
Vasya knows that the durability of the i-th can is a_i. It means that if Vasya has already knocked x cans down and is now about to start shooting the i-th one, he will need (a_i β
x + 1) shots to knock it down. You can assume that if Vasya starts shooting the i-th can, he will be shooting it until he knocks it down.
Your task is to choose such an order of shooting so that the number of shots required to knock each of the n given cans down exactly once is minimum possible.
Input
The first line of the input contains one integer n (2 β€ n β€ 1 000) β the number of cans.
The second line of the input contains the sequence a_1, a_2, ..., a_n (1 β€ a_i β€ 1 000), where a_i is the durability of the i-th can.
Output
In the first line print the minimum number of shots required to knock each of the n given cans down exactly once.
In the second line print the sequence consisting of n distinct integers from 1 to n β the order of indices of cans that minimizes the number of shots required. If there are several answers, you can print any of them.
Examples
Input
3
20 10 20
Output
43
1 3 2
Input
4
10 10 10 10
Output
64
2 1 4 3
Input
6
5 4 5 4 4 5
Output
69
6 1 3 5 2 4
Input
2
1 4
Output
3
2 1
Note
In the first example Vasya can start shooting from the first can. He knocks it down with the first shot because he haven't knocked any other cans down before. After that he has to shoot the third can. To knock it down he shoots 20 β
1 + 1 = 21 times. After that only second can remains. To knock it down Vasya shoots 10 β
2 + 1 = 21 times. So the total number of shots is 1 + 21 + 21 = 43.
In the second example the order of shooting does not matter because all cans have the same durability.
Submitted Solution:
```
def arr_enu():
return [[i + 1, int(x)] for i, x in enumerate(input().split())]
def print_arr(arr):
print(*arr, sep=' ')
def get_col(arr, i):
return [row[i] for row in arr]
n, a, out = int(input()), arr_enu(), 1
a.sort(reverse=True, key=lambda x: x[1])
for i in range(1, n):
out += a[i][1] * i + 1
print(out)
print_arr(get_col(a,0))
``` | instruction | 0 | 3,435 | 19 | 6,870 |
Yes | output | 1 | 3,435 | 19 | 6,871 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently Vasya decided to improve his pistol shooting skills. Today his coach offered him the following exercise. He placed n cans in a row on a table. Cans are numbered from left to right from 1 to n. Vasya has to knock down each can exactly once to finish the exercise. He is allowed to choose the order in which he will knock the cans down.
Vasya knows that the durability of the i-th can is a_i. It means that if Vasya has already knocked x cans down and is now about to start shooting the i-th one, he will need (a_i β
x + 1) shots to knock it down. You can assume that if Vasya starts shooting the i-th can, he will be shooting it until he knocks it down.
Your task is to choose such an order of shooting so that the number of shots required to knock each of the n given cans down exactly once is minimum possible.
Input
The first line of the input contains one integer n (2 β€ n β€ 1 000) β the number of cans.
The second line of the input contains the sequence a_1, a_2, ..., a_n (1 β€ a_i β€ 1 000), where a_i is the durability of the i-th can.
Output
In the first line print the minimum number of shots required to knock each of the n given cans down exactly once.
In the second line print the sequence consisting of n distinct integers from 1 to n β the order of indices of cans that minimizes the number of shots required. If there are several answers, you can print any of them.
Examples
Input
3
20 10 20
Output
43
1 3 2
Input
4
10 10 10 10
Output
64
2 1 4 3
Input
6
5 4 5 4 4 5
Output
69
6 1 3 5 2 4
Input
2
1 4
Output
3
2 1
Note
In the first example Vasya can start shooting from the first can. He knocks it down with the first shot because he haven't knocked any other cans down before. After that he has to shoot the third can. To knock it down he shoots 20 β
1 + 1 = 21 times. After that only second can remains. To knock it down Vasya shoots 10 β
2 + 1 = 21 times. So the total number of shots is 1 + 21 + 21 = 43.
In the second example the order of shooting does not matter because all cans have the same durability.
Submitted Solution:
```
n = int(input())
a = [int(x) for x in input().split()]
ans = 0
k = 0
d = dict()
b = []
for i in range(n):
b.append(a[i])
b.sort(reverse=True)
for i in range(len(b)):
ans += b[i] * k + 1
k += 1
if b[i] in d:
d[b[i]].append(i)
else:
d[b[i]] = [i]
print(ans)
for i in range(n):
print(d[a[i]][0] + 1, end=' ')
if len(d[a[i]]) > 1:
d[a[i]] = d[a[i]][1:]
# def minn():
# mnn = 10000000
# for i in range(len(a)):
# if mnn > a[i] and a[i] != 0:
# mnn = a[i]
# return mnn
#
#
# n = int(input())
# a = [int(x) for x in input().split()]
# if n == 2:
# print(1, max(a) - min(a))
# exit()
# mn = minn()
# k = mn
# for i in range(n):
# if a[i] % mn != 0:
# k = 1
# mx = max(a)
# g = 0
# for i in range(n):
# g += (mx - a[i]) // k
# print(g, k)
``` | instruction | 0 | 3,436 | 19 | 6,872 |
No | output | 1 | 3,436 | 19 | 6,873 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently Vasya decided to improve his pistol shooting skills. Today his coach offered him the following exercise. He placed n cans in a row on a table. Cans are numbered from left to right from 1 to n. Vasya has to knock down each can exactly once to finish the exercise. He is allowed to choose the order in which he will knock the cans down.
Vasya knows that the durability of the i-th can is a_i. It means that if Vasya has already knocked x cans down and is now about to start shooting the i-th one, he will need (a_i β
x + 1) shots to knock it down. You can assume that if Vasya starts shooting the i-th can, he will be shooting it until he knocks it down.
Your task is to choose such an order of shooting so that the number of shots required to knock each of the n given cans down exactly once is minimum possible.
Input
The first line of the input contains one integer n (2 β€ n β€ 1 000) β the number of cans.
The second line of the input contains the sequence a_1, a_2, ..., a_n (1 β€ a_i β€ 1 000), where a_i is the durability of the i-th can.
Output
In the first line print the minimum number of shots required to knock each of the n given cans down exactly once.
In the second line print the sequence consisting of n distinct integers from 1 to n β the order of indices of cans that minimizes the number of shots required. If there are several answers, you can print any of them.
Examples
Input
3
20 10 20
Output
43
1 3 2
Input
4
10 10 10 10
Output
64
2 1 4 3
Input
6
5 4 5 4 4 5
Output
69
6 1 3 5 2 4
Input
2
1 4
Output
3
2 1
Note
In the first example Vasya can start shooting from the first can. He knocks it down with the first shot because he haven't knocked any other cans down before. After that he has to shoot the third can. To knock it down he shoots 20 β
1 + 1 = 21 times. After that only second can remains. To knock it down Vasya shoots 10 β
2 + 1 = 21 times. So the total number of shots is 1 + 21 + 21 = 43.
In the second example the order of shooting does not matter because all cans have the same durability.
Submitted Solution:
```
n = int(input())
l = list(map(int,input().split()))
a=[]
for i in range(n):
a.append([l[i],i+1])
a.sort(reverse=True)
l=[]
for i in range(n):
l.append(a[i][1])
print(*l)
``` | instruction | 0 | 3,437 | 19 | 6,874 |
No | output | 1 | 3,437 | 19 | 6,875 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently Vasya decided to improve his pistol shooting skills. Today his coach offered him the following exercise. He placed n cans in a row on a table. Cans are numbered from left to right from 1 to n. Vasya has to knock down each can exactly once to finish the exercise. He is allowed to choose the order in which he will knock the cans down.
Vasya knows that the durability of the i-th can is a_i. It means that if Vasya has already knocked x cans down and is now about to start shooting the i-th one, he will need (a_i β
x + 1) shots to knock it down. You can assume that if Vasya starts shooting the i-th can, he will be shooting it until he knocks it down.
Your task is to choose such an order of shooting so that the number of shots required to knock each of the n given cans down exactly once is minimum possible.
Input
The first line of the input contains one integer n (2 β€ n β€ 1 000) β the number of cans.
The second line of the input contains the sequence a_1, a_2, ..., a_n (1 β€ a_i β€ 1 000), where a_i is the durability of the i-th can.
Output
In the first line print the minimum number of shots required to knock each of the n given cans down exactly once.
In the second line print the sequence consisting of n distinct integers from 1 to n β the order of indices of cans that minimizes the number of shots required. If there are several answers, you can print any of them.
Examples
Input
3
20 10 20
Output
43
1 3 2
Input
4
10 10 10 10
Output
64
2 1 4 3
Input
6
5 4 5 4 4 5
Output
69
6 1 3 5 2 4
Input
2
1 4
Output
3
2 1
Note
In the first example Vasya can start shooting from the first can. He knocks it down with the first shot because he haven't knocked any other cans down before. After that he has to shoot the third can. To knock it down he shoots 20 β
1 + 1 = 21 times. After that only second can remains. To knock it down Vasya shoots 10 β
2 + 1 = 21 times. So the total number of shots is 1 + 21 + 21 = 43.
In the second example the order of shooting does not matter because all cans have the same durability.
Submitted Solution:
```
# cook your dish here
n = int(input())
j = 0
a = []
for i in input().split():
t = []
t.append(int(i))
t.append(j)
t.append(0)
a.append(t)
j += 1
a = sorted(a,key =lambda x: x[0])
# print(a)
x = 0
to = 0
j = 1
for i in range(n-1,-1,-1):
to += a[i][0]*x + 1
x += 1
a[i][2] = j
j += 1
a = sorted(a,key = lambda x:x[1])
print(to)
for i in range(n):
print(a[i][2]) if i==n-1 else print(a[i][2],end=" ")
``` | instruction | 0 | 3,438 | 19 | 6,876 |
No | output | 1 | 3,438 | 19 | 6,877 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently Vasya decided to improve his pistol shooting skills. Today his coach offered him the following exercise. He placed n cans in a row on a table. Cans are numbered from left to right from 1 to n. Vasya has to knock down each can exactly once to finish the exercise. He is allowed to choose the order in which he will knock the cans down.
Vasya knows that the durability of the i-th can is a_i. It means that if Vasya has already knocked x cans down and is now about to start shooting the i-th one, he will need (a_i β
x + 1) shots to knock it down. You can assume that if Vasya starts shooting the i-th can, he will be shooting it until he knocks it down.
Your task is to choose such an order of shooting so that the number of shots required to knock each of the n given cans down exactly once is minimum possible.
Input
The first line of the input contains one integer n (2 β€ n β€ 1 000) β the number of cans.
The second line of the input contains the sequence a_1, a_2, ..., a_n (1 β€ a_i β€ 1 000), where a_i is the durability of the i-th can.
Output
In the first line print the minimum number of shots required to knock each of the n given cans down exactly once.
In the second line print the sequence consisting of n distinct integers from 1 to n β the order of indices of cans that minimizes the number of shots required. If there are several answers, you can print any of them.
Examples
Input
3
20 10 20
Output
43
1 3 2
Input
4
10 10 10 10
Output
64
2 1 4 3
Input
6
5 4 5 4 4 5
Output
69
6 1 3 5 2 4
Input
2
1 4
Output
3
2 1
Note
In the first example Vasya can start shooting from the first can. He knocks it down with the first shot because he haven't knocked any other cans down before. After that he has to shoot the third can. To knock it down he shoots 20 β
1 + 1 = 21 times. After that only second can remains. To knock it down Vasya shoots 10 β
2 + 1 = 21 times. So the total number of shots is 1 + 21 + 21 = 43.
In the second example the order of shooting does not matter because all cans have the same durability.
Submitted Solution:
```
n = int(input())
datas = list(map(int,input().split()))
answer = [0 for i in range(n)]
dic = dict()
for i,data in enumerate(datas):
if dic.get(data)==None:
dic[data]=[i]
else:
dic[data].append(i)
items = list(dic.items())
items.sort(key = lambda x:x[0], reverse = True)
count = 0
answer_num = 0
for item in items:
for i in item[1]:
answer[i] = count
answer_num+= count*item[0]+1
count+=1
print(answer_num)
print(*answer)
``` | instruction | 0 | 3,439 | 19 | 6,878 |
No | output | 1 | 3,439 | 19 | 6,879 |
Provide a correct Python 3 solution for this coding contest problem.
problem
Prepare the Othello board. The upper left is $ (1,1) $ and the lower right is $ (8,8) $. The board to be prepared here is $ (5,4) as follows. ) There is no $ black stone.
........
........
........
... ox ...
.... o ...
........
........
........
Kuroishi: x Shiraishi: o
8x8 board
From this state, Black starts Othello first.
AOR Ika-chan plays $ q $ times according to the following rules.
A rectangular area is given, with the upper left as the cell in the $ a $ and $ b $ columns, and the lower right as the cell in the $ c $ and $ d $ columns.
AOR Ika-chan puts black stones and white stones alternately according to the rules of Othello (reference: Wikipedia Othello) so as to maximize the number of stones contained in this rectangular area.
When no more stones can be placed (when both Shiraishi and Kuroishi have to pass or when all the boards are filled), the game ends.
In each game, output the number of stones when the number of stones contained in the area is maximized.
Since the number of inputs and outputs may increase, it is recommended to use high-speed functions for input and output.
output
In each game, output the number of stones in the area when the number of stones is maximized. Also, output a line break at the end.
Example
Input
3
1 1 8 8
2 4 3 8
8 8 8 8
Output
48
7
1 | instruction | 0 | 4,130 | 19 | 8,260 |
"Correct Solution:
```
def inpl(): return list(map(int, input().split()))
from collections import defaultdict
G = dict()
for i in range(9):
G[(i, 9)] = 0
G[(9, i)] = 0
G[(9, 9)] = 0
for i in range(8)[::-1]:
a = 8 - i
b = -(-(8 - i)//2)
i= i+1
for j in range(8)[::-1]:
if j % 2 == 1:
j = j+1
G[(i, j)] = G[(i, j+1)] + b
else:
j = j+1
G[(i, j)] = G[(i, j+1)] + a
q = int(input())
for _ in range(q):
a, b, c, d = inpl()
print(G[(a, b)] - G[(c+1, b)] - G[(a, d+1)] + G[(c+1), (d+1)])
``` | output | 1 | 4,130 | 19 | 8,261 |
Provide a correct Python 3 solution for this coding contest problem.
problem
Prepare the Othello board. The upper left is $ (1,1) $ and the lower right is $ (8,8) $. The board to be prepared here is $ (5,4) as follows. ) There is no $ black stone.
........
........
........
... ox ...
.... o ...
........
........
........
Kuroishi: x Shiraishi: o
8x8 board
From this state, Black starts Othello first.
AOR Ika-chan plays $ q $ times according to the following rules.
A rectangular area is given, with the upper left as the cell in the $ a $ and $ b $ columns, and the lower right as the cell in the $ c $ and $ d $ columns.
AOR Ika-chan puts black stones and white stones alternately according to the rules of Othello (reference: Wikipedia Othello) so as to maximize the number of stones contained in this rectangular area.
When no more stones can be placed (when both Shiraishi and Kuroishi have to pass or when all the boards are filled), the game ends.
In each game, output the number of stones when the number of stones contained in the area is maximized.
Since the number of inputs and outputs may increase, it is recommended to use high-speed functions for input and output.
output
In each game, output the number of stones in the area when the number of stones is maximized. Also, output a line break at the end.
Example
Input
3
1 1 8 8
2 4 3 8
8 8 8 8
Output
48
7
1 | instruction | 0 | 4,131 | 19 | 8,262 |
"Correct Solution:
```
#!usr/bin/env python3
from collections import defaultdict
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS():return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]
def IR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = I()
return l
def LIR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = LI()
return l
def SR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = S()
return l
def LSR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = SR()
return l
mod = 1000000007
#A
"""
h,w = LI()
a,b = LI()
y = h//a
x = w//b
ans = h*w-a*y*b*x
print(ans)
"""
#B
"""
def m(x,y):
if x == y:
return "T"
if x == "F":
return "T"
return "F"
n = I()
p = input().split()
ans = p[0]
for i in range(1,n):
ans = m(ans,p[i])
print(ans)
"""
#C
s = [[1]*8 for i in range(4)]
for i in range(4):
s.insert(2*i,[1,0,1,0,1,0,1,0])
for j in range(8):
for i in range(1,8):
s[j][i] += s[j][i-1]
for j in range(8):
for i in range(1,8):
s[i][j] += s[i-1][j]
s.insert(0,[0,0,0,0,0,0,0,0,0])
for i in range(1,9):
s[i].insert(0,0)
q = I()
for _ in range(q):
a,b,c,d = LI()
print(s[c][d]-s[c][b-1]-s[a-1][d]+s[a-1][b-1])
#D
"""
n = I()
a = LI()
dp = [float("inf") for i in range(n)]
b = [[] for i in range(n)]
ind = [0 for i in range(100001)]
for i in range(n):
k = bisect.bisect_left(dp,a[i])
dp[k] = a[i]
b[k].append(a[i])
ind[a[i]] = max(i,ind[a[i]])
for i in range(n):
if dp[i] == float("inf"):break
b[i].sort()
b[i] = b[i][::-1]
i -= 1
ans = b[i][0]
now_ind = ind[b[i][0]]
now_v = b[i][0]
while i >= 0:
for j in b[i]:
if ind[j] < now_ind and j < now_v:
ans += j
now_ind = ind[j]
now_v = j
i -= 1
print(ans)
"""
#E
#F
#G
#H
#I
#J
#K
#L
#M
#N
#O
#P
#Q
#R
#S
#T
``` | output | 1 | 4,131 | 19 | 8,263 |
Provide a correct Python 3 solution for this coding contest problem.
problem
Prepare the Othello board. The upper left is $ (1,1) $ and the lower right is $ (8,8) $. The board to be prepared here is $ (5,4) as follows. ) There is no $ black stone.
........
........
........
... ox ...
.... o ...
........
........
........
Kuroishi: x Shiraishi: o
8x8 board
From this state, Black starts Othello first.
AOR Ika-chan plays $ q $ times according to the following rules.
A rectangular area is given, with the upper left as the cell in the $ a $ and $ b $ columns, and the lower right as the cell in the $ c $ and $ d $ columns.
AOR Ika-chan puts black stones and white stones alternately according to the rules of Othello (reference: Wikipedia Othello) so as to maximize the number of stones contained in this rectangular area.
When no more stones can be placed (when both Shiraishi and Kuroishi have to pass or when all the boards are filled), the game ends.
In each game, output the number of stones when the number of stones contained in the area is maximized.
Since the number of inputs and outputs may increase, it is recommended to use high-speed functions for input and output.
output
In each game, output the number of stones in the area when the number of stones is maximized. Also, output a line break at the end.
Example
Input
3
1 1 8 8
2 4 3 8
8 8 8 8
Output
48
7
1 | instruction | 0 | 4,132 | 19 | 8,264 |
"Correct Solution:
```
q = int(input())
li = [input().split() for i in range(q)]
for i in li:
a, b, c, d = map(int, i)
ans = 0
for j in range(a, c+1):
for k in range(b, d+1):
ans += 0 if j%2 == 1 and k%2 == 0 else 1
print(ans)
``` | output | 1 | 4,132 | 19 | 8,265 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Two kittens, Max and Min, play with a pair of non-negative integers x and y. As you can guess from their names, kitten Max loves to maximize and kitten Min loves to minimize. As part of this game Min wants to make sure that both numbers, x and y became negative at the same time, and kitten Max tries to prevent him from doing so.
Each kitten has a set of pairs of integers available to it. Kitten Max has n pairs of non-negative integers (ai, bi) (1 β€ i β€ n), and kitten Min has m pairs of non-negative integers (cj, dj) (1 β€ j β€ m). As kitten Max makes a move, it can take any available pair (ai, bi) and add ai to x and bi to y, and kitten Min can take any available pair (cj, dj) and subtract cj from x and dj from y. Each kitten can use each pair multiple times during distinct moves.
Max moves first. Kitten Min is winning if at some moment both numbers a, b are negative simultaneously. Otherwise, the winner of the game is kitten Max. Determine which kitten wins if both of them play optimally.
Input
The first line contains two integers, n and m (1 β€ n, m β€ 100 000) β the number of pairs of numbers available to Max and Min, correspondingly.
The second line contains two integers x, y (1 β€ x, y β€ 109) β the initial values of numbers with which the kittens are playing.
Next n lines contain the pairs of numbers ai, bi (1 β€ ai, bi β€ 109) β the pairs available to Max.
The last m lines contain pairs of numbers cj, dj (1 β€ cj, dj β€ 109) β the pairs available to Min.
Output
Print Β«MaxΒ» (without the quotes), if kitten Max wins, or "Min" (without the quotes), if kitten Min wins.
Examples
Input
2 2
42 43
2 3
3 2
3 10
10 3
Output
Min
Input
1 1
1 1
3 4
1 1
Output
Max
Note
In the first test from the statement Min can respond to move (2, 3) by move (3, 10), and to move (3, 2) by move (10, 3). Thus, for each pair of Max and Min's moves the values of both numbers x and y will strictly decrease, ergo, Min will win sooner or later.
In the second sample test after each pair of Max and Min's moves both numbers x and y only increase, thus none of them will become negative.
Submitted Solution:
```
#encoding:utf-8
import math
strsRounds = input()
tmp = strsRounds.split(' ')
roundMax = int(tmp[0])
roundMin = int(tmp[1])
rounds = roundMax + roundMin
strsNums = input()
tmp = strsNums.split(' ')
baseNum1 = int(tmp[0])
baseNum2 = int(tmp[1])
baseDif = baseNum1 - baseNum2
strsListMax = []
strsListMin = []
xOperMax = 0
yOperMax = 0
xOperMin = 0
yOperMin = 0
for inputL in range(roundMax):
tmpstr = input()
tmpList = tmpstr.split(' ')
tmpList.append(int(tmpList[0])-int(tmpList[1]))
if xOperMax < int(tmpList[0]):
xOperMax = int(tmpList[0])
if yOperMax < int(tmpList[1]):
yOperMax = int(tmpList[1])
strsListMax.append(tmpList)
strsListMax.append(tmpList)
for inputL in range(roundMin):
tmpstr = input()
tmpList = tmpstr.split(' ')
tmpList.append(int(tmpList[0])-int(tmpList[1]))
if xOperMin < int(tmpList[0]):
xOperMin = int(tmpList[0])
if yOperMin < int(tmpList[1]):
yOperMin = int(tmpList[1])
strsListMin.append(tmpList)
if (xOperMax >= xOperMin) or (yOperMax >= yOperMin):
print ("Max")
else:
print ("Min")
``` | instruction | 0 | 4,599 | 19 | 9,198 |
No | output | 1 | 4,599 | 19 | 9,199 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Two kittens, Max and Min, play with a pair of non-negative integers x and y. As you can guess from their names, kitten Max loves to maximize and kitten Min loves to minimize. As part of this game Min wants to make sure that both numbers, x and y became negative at the same time, and kitten Max tries to prevent him from doing so.
Each kitten has a set of pairs of integers available to it. Kitten Max has n pairs of non-negative integers (ai, bi) (1 β€ i β€ n), and kitten Min has m pairs of non-negative integers (cj, dj) (1 β€ j β€ m). As kitten Max makes a move, it can take any available pair (ai, bi) and add ai to x and bi to y, and kitten Min can take any available pair (cj, dj) and subtract cj from x and dj from y. Each kitten can use each pair multiple times during distinct moves.
Max moves first. Kitten Min is winning if at some moment both numbers a, b are negative simultaneously. Otherwise, the winner of the game is kitten Max. Determine which kitten wins if both of them play optimally.
Input
The first line contains two integers, n and m (1 β€ n, m β€ 100 000) β the number of pairs of numbers available to Max and Min, correspondingly.
The second line contains two integers x, y (1 β€ x, y β€ 109) β the initial values of numbers with which the kittens are playing.
Next n lines contain the pairs of numbers ai, bi (1 β€ ai, bi β€ 109) β the pairs available to Max.
The last m lines contain pairs of numbers cj, dj (1 β€ cj, dj β€ 109) β the pairs available to Min.
Output
Print Β«MaxΒ» (without the quotes), if kitten Max wins, or "Min" (without the quotes), if kitten Min wins.
Examples
Input
2 2
42 43
2 3
3 2
3 10
10 3
Output
Min
Input
1 1
1 1
3 4
1 1
Output
Max
Note
In the first test from the statement Min can respond to move (2, 3) by move (3, 10), and to move (3, 2) by move (10, 3). Thus, for each pair of Max and Min's moves the values of both numbers x and y will strictly decrease, ergo, Min will win sooner or later.
In the second sample test after each pair of Max and Min's moves both numbers x and y only increase, thus none of them will become negative.
Submitted Solution:
```
import sys
import math
input = sys.stdin.readline
n, m = map(int, input().split())
p, q = map(int, input().split())
first = []
for i in range(n):
x, y = map(int, input().split())
first.append((x, y))
maxX, maxY, maxSum = 0, 0, 0
for i in range(m):
x, y = map(int, input().split())
maxX = max(maxX, x)
maxY = max(maxY, y)
maxSum = max(maxSum, x + y)
for i in first:
if i[0] >= maxX or i[1] >= maxY or i[0] + i[1] >= maxSum:
print('Max')
exit(0)
print('Min')
``` | instruction | 0 | 4,600 | 19 | 9,200 |
No | output | 1 | 4,600 | 19 | 9,201 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Two kittens, Max and Min, play with a pair of non-negative integers x and y. As you can guess from their names, kitten Max loves to maximize and kitten Min loves to minimize. As part of this game Min wants to make sure that both numbers, x and y became negative at the same time, and kitten Max tries to prevent him from doing so.
Each kitten has a set of pairs of integers available to it. Kitten Max has n pairs of non-negative integers (ai, bi) (1 β€ i β€ n), and kitten Min has m pairs of non-negative integers (cj, dj) (1 β€ j β€ m). As kitten Max makes a move, it can take any available pair (ai, bi) and add ai to x and bi to y, and kitten Min can take any available pair (cj, dj) and subtract cj from x and dj from y. Each kitten can use each pair multiple times during distinct moves.
Max moves first. Kitten Min is winning if at some moment both numbers a, b are negative simultaneously. Otherwise, the winner of the game is kitten Max. Determine which kitten wins if both of them play optimally.
Input
The first line contains two integers, n and m (1 β€ n, m β€ 100 000) β the number of pairs of numbers available to Max and Min, correspondingly.
The second line contains two integers x, y (1 β€ x, y β€ 109) β the initial values of numbers with which the kittens are playing.
Next n lines contain the pairs of numbers ai, bi (1 β€ ai, bi β€ 109) β the pairs available to Max.
The last m lines contain pairs of numbers cj, dj (1 β€ cj, dj β€ 109) β the pairs available to Min.
Output
Print Β«MaxΒ» (without the quotes), if kitten Max wins, or "Min" (without the quotes), if kitten Min wins.
Examples
Input
2 2
42 43
2 3
3 2
3 10
10 3
Output
Min
Input
1 1
1 1
3 4
1 1
Output
Max
Note
In the first test from the statement Min can respond to move (2, 3) by move (3, 10), and to move (3, 2) by move (10, 3). Thus, for each pair of Max and Min's moves the values of both numbers x and y will strictly decrease, ergo, Min will win sooner or later.
In the second sample test after each pair of Max and Min's moves both numbers x and y only increase, thus none of them will become negative.
Submitted Solution:
```
n,m=map(int,input().split())
x,y=map(int,input().split())
ma=mi=0
for i in range(n): ma=max(ma,max(map(int,input().split())))
for i in range(m): mi=max(mi,max(map(int,input().split())))
print('Min' if mi>ma else 'Max')
``` | instruction | 0 | 4,601 | 19 | 9,202 |
No | output | 1 | 4,601 | 19 | 9,203 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Two kittens, Max and Min, play with a pair of non-negative integers x and y. As you can guess from their names, kitten Max loves to maximize and kitten Min loves to minimize. As part of this game Min wants to make sure that both numbers, x and y became negative at the same time, and kitten Max tries to prevent him from doing so.
Each kitten has a set of pairs of integers available to it. Kitten Max has n pairs of non-negative integers (ai, bi) (1 β€ i β€ n), and kitten Min has m pairs of non-negative integers (cj, dj) (1 β€ j β€ m). As kitten Max makes a move, it can take any available pair (ai, bi) and add ai to x and bi to y, and kitten Min can take any available pair (cj, dj) and subtract cj from x and dj from y. Each kitten can use each pair multiple times during distinct moves.
Max moves first. Kitten Min is winning if at some moment both numbers a, b are negative simultaneously. Otherwise, the winner of the game is kitten Max. Determine which kitten wins if both of them play optimally.
Input
The first line contains two integers, n and m (1 β€ n, m β€ 100 000) β the number of pairs of numbers available to Max and Min, correspondingly.
The second line contains two integers x, y (1 β€ x, y β€ 109) β the initial values of numbers with which the kittens are playing.
Next n lines contain the pairs of numbers ai, bi (1 β€ ai, bi β€ 109) β the pairs available to Max.
The last m lines contain pairs of numbers cj, dj (1 β€ cj, dj β€ 109) β the pairs available to Min.
Output
Print Β«MaxΒ» (without the quotes), if kitten Max wins, or "Min" (without the quotes), if kitten Min wins.
Examples
Input
2 2
42 43
2 3
3 2
3 10
10 3
Output
Min
Input
1 1
1 1
3 4
1 1
Output
Max
Note
In the first test from the statement Min can respond to move (2, 3) by move (3, 10), and to move (3, 2) by move (10, 3). Thus, for each pair of Max and Min's moves the values of both numbers x and y will strictly decrease, ergo, Min will win sooner or later.
In the second sample test after each pair of Max and Min's moves both numbers x and y only increase, thus none of them will become negative.
Submitted Solution:
```
n,m=map(int,input().split())
x,y=map(int,input().split())
ma1=ma2=mi1=mi2=0
for i in range(n):
a,b=map(int,input().split())
ma1=max(ma1,a)
ma2=max(ma2,b)
for i in range(m):
a,b=map(int,input().split())
mi1=max(mi1,a)
mi2=max(mi2,b)
print('Min' if mi1>ma1 or mi2>ma2 else 'Max')
``` | instruction | 0 | 4,602 | 19 | 9,204 |
No | output | 1 | 4,602 | 19 | 9,205 |
Provide a correct Python 3 solution for this coding contest problem.
Life is not easy. Sometimes it is beyond your control. Now, as contestants of ACM ICPC, you might be just tasting the bitter of life. But don't worry! Do not look only on the dark side of life, but look also on the bright side. Life may be an enjoyable game of chance, like throwing dice. Do or die! Then, at last, you might be able to find the route to victory.
This problem comes from a game using a die. By the way, do you know a die? It has nothing to do with "death." A die is a cubic object with six faces, each of which represents a different number from one to six and is marked with the corresponding number of spots. Since it is usually used in pair, "a die" is rarely used word. You might have heard a famous phrase "the die is cast," though.
When a game starts, a die stands still on a flat table. During the game, the die is tumbled in all directions by the dealer. You will win the game if you can predict the number seen on the top face at the time when the die stops tumbling.
Now you are requested to write a program that simulates the rolling of a die. For simplicity, we assume that the die neither slip nor jumps but just rolls on the table in four directions, that is, north, east, south, and west. At the beginning of every game, the dealer puts the die at the center of the table and adjusts its direction so that the numbers one, two, and three are seen on the top, north, and west faces, respectively. For the other three faces, we do not explicitly specify anything but tell you the golden rule: the sum of the numbers on any pair of opposite faces is always seven.
Your program should accept a sequence of commands, each of which is either "north", "east", "south", or "west". A "north" command tumbles the die down to north, that is, the top face becomes the new north, the north becomes the new bottom, and so on. More precisely, the die is rotated around its north bottom edge to the north direction and the rotation angle is 9 degrees. Other commands also tumble the die accordingly to their own directions. Your program should calculate the number finally shown on the top after performing the commands in the sequence. Note that the table is sufficiently large and the die never falls off during the game.
Input
The input consists of one or more command sequences, each of which corresponds to a single game. The first line of a command sequence contains a positive integer, representing the number of the following command lines in the sequence. You may assume that this number is less than or equal to 1024. A line containing a zero indicates the end of the input. Each command line includes a command that is one of north, east, south, and west. You may assume that no white space occurs in any line.
Output
For each command sequence, output one line containing solely the number of the top face at the time when the game is finished.
Example
Input
1
north
3
north
east
south
0
Output
5
1 | instruction | 0 | 4,982 | 19 | 9,964 |
"Correct Solution:
```
# AOJ 1210: Die Game
# Python3 2018.7.22 bal4u
dic = {'s':1, 'w':2, 'e':3, 'n':4}
rot = [[0,1,2,3,4,5,6],[0,2,6,3,4,1,5],[0,4,2,1,6,5,3],[0,3,2,6,1,5,4],[0,5,1,3,4,6,2]]
while True:
n = int(input())
if n == 0: break
dice = [i for i in range(7)]
for j in range(n):
a = input()[0]
dice = [dice[rot[dic[a]][i]] for i in range(7)]
print(dice[1])
``` | output | 1 | 4,982 | 19 | 9,965 |
Provide a correct Python 3 solution for this coding contest problem.
Problem statement
A $ 2 $ human-player match-up game tournament is about to take place in front of Kyoto University Camphor Tree.
There are $ 2 ^ N $ participants in this tournament, numbered from $ 1 $ to $ 2 ^ N $.
Winning or losing when $ 2 $ of participants fight is represented by the $ 2 ^ N-1 $ string $ S $ consisting of $ 0 $ and $ 1 $.
When people $ x $ and people $ y $$ (1 \ le x <y \ le 2 ^ N) $ fight
* When $ S_ {y-x} = 0 $, the person $ x $ wins,
* When $ S_ {y-x} = 1 $, the person $ y $ wins
I know that.
The tournament begins with a line of participants and proceeds as follows:
1. Make a pair of $ 2 $ people from the beginning of the column. For every pair, $ 2 $ people in the pair fight.
2. Those who win the match in 1 will remain in the line, and those who lose will leave the line.
3. If there are more than $ 2 $ left, fill the column back to 1.
4. If there are $ 1 $ left, that person will be the winner.
Now, the participants are initially arranged so that the $ i $ th $ (1 \ le i \ le 2 ^ N) $ from the beginning becomes the person $ P_i $.
Solve the following problem for all integers $ k $ that satisfy $ 0 \ le k \ le 2 ^ N-1 $.
* From the initial state, the first $ k $ person moves to the end of the column without changing the order.
* In other words, if you list the number of participants in the moved column from the beginning, $ P_ {k + 1}, P_ {k + 2}, ..., P_ {2 ^ N}, P_1, P_2, ..., P_k $.
* Find the winner's number when you start the tournament from the line after the move.
Constraint
* $ 1 \ leq N \ leq 18 $
* $ N $ is an integer.
* $ S $ is a $ 2 ^ N-1 $ string consisting of $ 0 $ and $ 1 $.
* $ P $ is a permutation of integers from $ 1 $ to $ 2 ^ N $.
* * *
input
Input is given from standard input in the following format.
$ N $
$ S_1S_2 \ ldots S_ {2 ^ N-1} $
$ P_1 $ $ P_2 $ $ \ ldots $ $ P_ {2 ^ N} $
output
Output $ 2 ^ N $ lines.
In the $ i $ line $ (1 \ le i \ le 2 ^ N) $, output the answer to the above problem when $ k = i-1 $.
* * *
Input example 1
2
100
1 4 2 3
Output example 1
1
2
1
2
For example, if $ k = 2 $, the number of participants in the moved column will be $ 2, 3, 1, 4 $ from the beginning.
When person $ 2 $ and person $ 3 $ fight, person $ 3 $ wins over $ S_1 = 1 $.
When person $ 1 $ and person $ 4 $ fight, person $ 1 $ wins over $ S_3 = 0 $.
When person $ 3 $ and person $ 1 $ fight, person $ 1 $ wins over $ S_2 = 0 $.
Therefore, if $ k = 2 $, the winner would be $ 1 $ person.
* * *
Input example 2
Four
101011100101000
8 15 2 9 12 5 1 7 14 10 11 3 4 6 16 13
Output example 2
16
1
16
2
16
12
Ten
14
16
1
16
2
16
12
Ten
14
* * *
Input example 3
1
0
1 2
Output example 3
1
1
Example
Input
2
100
1 4 2 3
Output
1
2
1
2 | instruction | 0 | 4,994 | 19 | 9,988 |
"Correct Solution:
```
#!usr/bin/env python3
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
def f(a, b):
return max(a, b) if s[abs(a-b)-1] == "1" else min(a,b)
n = I()
s = S()
# print(s)
p = LI()
dp = [[0 if j else p[i] for j in range(n+1)] for i in range(1 << n)]
maxn = 1 << n
for j in range(n):
j1 = 1 << j
for i in range(1 << n):
if i + j1 >= maxn:
# print(i+j1-n,i,j)
dp[i][j+1] = f(dp[i][j],dp[i+j1-maxn][j])
else:
dp[i][j+1] = f(dp[i][j],dp[i+j1][j])
# print(dp[0][0],dp[1][0],f(dp[0][0],dp[1][0]))
# print(dp)
for i in range(1 << n):
print(dp[i][-1])
# pass
return
#Solve
if __name__ == "__main__":
solve()
``` | output | 1 | 4,994 | 19 | 9,989 |
Provide a correct Python 3 solution for this coding contest problem.
Problem statement
A $ 2 $ human-player match-up game tournament is about to take place in front of Kyoto University Camphor Tree.
There are $ 2 ^ N $ participants in this tournament, numbered from $ 1 $ to $ 2 ^ N $.
Winning or losing when $ 2 $ of participants fight is represented by the $ 2 ^ N-1 $ string $ S $ consisting of $ 0 $ and $ 1 $.
When people $ x $ and people $ y $$ (1 \ le x <y \ le 2 ^ N) $ fight
* When $ S_ {y-x} = 0 $, the person $ x $ wins,
* When $ S_ {y-x} = 1 $, the person $ y $ wins
I know that.
The tournament begins with a line of participants and proceeds as follows:
1. Make a pair of $ 2 $ people from the beginning of the column. For every pair, $ 2 $ people in the pair fight.
2. Those who win the match in 1 will remain in the line, and those who lose will leave the line.
3. If there are more than $ 2 $ left, fill the column back to 1.
4. If there are $ 1 $ left, that person will be the winner.
Now, the participants are initially arranged so that the $ i $ th $ (1 \ le i \ le 2 ^ N) $ from the beginning becomes the person $ P_i $.
Solve the following problem for all integers $ k $ that satisfy $ 0 \ le k \ le 2 ^ N-1 $.
* From the initial state, the first $ k $ person moves to the end of the column without changing the order.
* In other words, if you list the number of participants in the moved column from the beginning, $ P_ {k + 1}, P_ {k + 2}, ..., P_ {2 ^ N}, P_1, P_2, ..., P_k $.
* Find the winner's number when you start the tournament from the line after the move.
Constraint
* $ 1 \ leq N \ leq 18 $
* $ N $ is an integer.
* $ S $ is a $ 2 ^ N-1 $ string consisting of $ 0 $ and $ 1 $.
* $ P $ is a permutation of integers from $ 1 $ to $ 2 ^ N $.
* * *
input
Input is given from standard input in the following format.
$ N $
$ S_1S_2 \ ldots S_ {2 ^ N-1} $
$ P_1 $ $ P_2 $ $ \ ldots $ $ P_ {2 ^ N} $
output
Output $ 2 ^ N $ lines.
In the $ i $ line $ (1 \ le i \ le 2 ^ N) $, output the answer to the above problem when $ k = i-1 $.
* * *
Input example 1
2
100
1 4 2 3
Output example 1
1
2
1
2
For example, if $ k = 2 $, the number of participants in the moved column will be $ 2, 3, 1, 4 $ from the beginning.
When person $ 2 $ and person $ 3 $ fight, person $ 3 $ wins over $ S_1 = 1 $.
When person $ 1 $ and person $ 4 $ fight, person $ 1 $ wins over $ S_3 = 0 $.
When person $ 3 $ and person $ 1 $ fight, person $ 1 $ wins over $ S_2 = 0 $.
Therefore, if $ k = 2 $, the winner would be $ 1 $ person.
* * *
Input example 2
Four
101011100101000
8 15 2 9 12 5 1 7 14 10 11 3 4 6 16 13
Output example 2
16
1
16
2
16
12
Ten
14
16
1
16
2
16
12
Ten
14
* * *
Input example 3
1
0
1 2
Output example 3
1
1
Example
Input
2
100
1 4 2 3
Output
1
2
1
2 | instruction | 0 | 4,995 | 19 | 9,990 |
"Correct Solution:
```
import sys
readline = sys.stdin.readline
N = int(readline())
Ns = 1<<N
S = [None]+list(map(int, readline().strip()))
P = list(map(int, readline().split()))
res = [None]*Ns
res[0] = P
res[1] = P[1:] + [P[0]]
Ans = [None]*Ns
for i in range(Ns):
ri = res[i]
leng = len(ri)
for level in range(leng.bit_length()-1):
cnt = []
for j in range(len(ri)//2):
a = ri[2*j]
b = ri[2*j+1]
if S[abs(a-b)] == 1:
cnt.append(max(a, b))
else:
cnt.append(min(a, b))
ri = cnt[:]
lri = len(ri)
if 1 < Ns//lri < Ns-i:
res[i + Ns//lri] = ri[1:] + [ri[0]]
Ans[i] = ri[0]
print('\n'.join(map(str, Ans)))
``` | output | 1 | 4,995 | 19 | 9,991 |
Provide a correct Python 3 solution for this coding contest problem.
Problem statement
A $ 2 $ human-player match-up game tournament is about to take place in front of Kyoto University Camphor Tree.
There are $ 2 ^ N $ participants in this tournament, numbered from $ 1 $ to $ 2 ^ N $.
Winning or losing when $ 2 $ of participants fight is represented by the $ 2 ^ N-1 $ string $ S $ consisting of $ 0 $ and $ 1 $.
When people $ x $ and people $ y $$ (1 \ le x <y \ le 2 ^ N) $ fight
* When $ S_ {y-x} = 0 $, the person $ x $ wins,
* When $ S_ {y-x} = 1 $, the person $ y $ wins
I know that.
The tournament begins with a line of participants and proceeds as follows:
1. Make a pair of $ 2 $ people from the beginning of the column. For every pair, $ 2 $ people in the pair fight.
2. Those who win the match in 1 will remain in the line, and those who lose will leave the line.
3. If there are more than $ 2 $ left, fill the column back to 1.
4. If there are $ 1 $ left, that person will be the winner.
Now, the participants are initially arranged so that the $ i $ th $ (1 \ le i \ le 2 ^ N) $ from the beginning becomes the person $ P_i $.
Solve the following problem for all integers $ k $ that satisfy $ 0 \ le k \ le 2 ^ N-1 $.
* From the initial state, the first $ k $ person moves to the end of the column without changing the order.
* In other words, if you list the number of participants in the moved column from the beginning, $ P_ {k + 1}, P_ {k + 2}, ..., P_ {2 ^ N}, P_1, P_2, ..., P_k $.
* Find the winner's number when you start the tournament from the line after the move.
Constraint
* $ 1 \ leq N \ leq 18 $
* $ N $ is an integer.
* $ S $ is a $ 2 ^ N-1 $ string consisting of $ 0 $ and $ 1 $.
* $ P $ is a permutation of integers from $ 1 $ to $ 2 ^ N $.
* * *
input
Input is given from standard input in the following format.
$ N $
$ S_1S_2 \ ldots S_ {2 ^ N-1} $
$ P_1 $ $ P_2 $ $ \ ldots $ $ P_ {2 ^ N} $
output
Output $ 2 ^ N $ lines.
In the $ i $ line $ (1 \ le i \ le 2 ^ N) $, output the answer to the above problem when $ k = i-1 $.
* * *
Input example 1
2
100
1 4 2 3
Output example 1
1
2
1
2
For example, if $ k = 2 $, the number of participants in the moved column will be $ 2, 3, 1, 4 $ from the beginning.
When person $ 2 $ and person $ 3 $ fight, person $ 3 $ wins over $ S_1 = 1 $.
When person $ 1 $ and person $ 4 $ fight, person $ 1 $ wins over $ S_3 = 0 $.
When person $ 3 $ and person $ 1 $ fight, person $ 1 $ wins over $ S_2 = 0 $.
Therefore, if $ k = 2 $, the winner would be $ 1 $ person.
* * *
Input example 2
Four
101011100101000
8 15 2 9 12 5 1 7 14 10 11 3 4 6 16 13
Output example 2
16
1
16
2
16
12
Ten
14
16
1
16
2
16
12
Ten
14
* * *
Input example 3
1
0
1 2
Output example 3
1
1
Example
Input
2
100
1 4 2 3
Output
1
2
1
2 | instruction | 0 | 4,996 | 19 | 9,992 |
"Correct Solution:
```
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
N = int(readline())
S = [0] + [int(x) - ord('0') for x in readline().rstrip()]
P = [int(x) for x in read().split()]
P += P
dp = [P]
for i in range(N+1):
P = dp[i]
newP = []
dx = 1<<i
for a,b in zip(P, P[dx:]):
if a > b:
a,b = b,a
if S[b-a]:
newP.append(b)
else:
newP.append(a)
dp.append(newP)
answers = (x for x in P[:-1])
print('\n'.join(map(str, answers)))
``` | output | 1 | 4,996 | 19 | 9,993 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Cardbluff is popular sport game in Telegram. Each Cardbluff player has ever dreamed about entrance in the professional layer. There are n judges now in the layer and you are trying to pass the entrance exam. You have a number k β your skill in Cardbluff.
Each judge has a number a_i β an indicator of uncertainty about your entrance to the professional layer and a number e_i β an experience playing Cardbluff. To pass the exam you need to convince all judges by playing with them. You can play only one game with each judge. As a result of a particular game, you can divide the uncertainty of i-th judge by any natural divisor of a_i which is at most k. If GCD of all indicators is equal to 1, you will enter to the professional layer and become a judge.
Also, you want to minimize the total amount of spent time. So, if you play with x judges with total experience y you will spend x β
y seconds.
Print minimal time to enter to the professional layer or -1 if it's impossible.
Input
There are two numbers in the first line n and k (1 β€ n β€ 10^6, 1 β€ k β€ 10^{12}) β the number of judges and your skill in Cardbluff.
The second line contains n integers, where i-th number a_i (1 β€ a_i β€ 10^{12}) β the uncertainty of i-th judge
The third line contains n integers in the same format (1 β€ e_i β€ 10^9), e_i β the experience of i-th judge.
Output
Print the single integer β minimal number of seconds to pass exam, or -1 if it's impossible
Examples
Input
3 6
30 30 30
100 4 5
Output
18
Input
1 1000000
1
100
Output
0
Input
3 5
7 7 7
1 1 1
Output
-1
Submitted Solution:
```
from sys import stdout
def ask(x,y) :
print('?',x,y)
stdout.flush()
return input() == 'x'
def work() :
if ask(0, 1) : return 1
l = 1
while ask(l*2,l) : l*=2
r = 2*1000000000
l += 1
while r > l :
mid=(l+r)//2
if ask(mid, (mid+1)//2) :
l=mid+1
else :
r=mid
return l
while input()=='start' :
print('!',work())
stdout.flush()
``` | instruction | 0 | 5,077 | 19 | 10,154 |
No | output | 1 | 5,077 | 19 | 10,155 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Cardbluff is popular sport game in Telegram. Each Cardbluff player has ever dreamed about entrance in the professional layer. There are n judges now in the layer and you are trying to pass the entrance exam. You have a number k β your skill in Cardbluff.
Each judge has a number a_i β an indicator of uncertainty about your entrance to the professional layer and a number e_i β an experience playing Cardbluff. To pass the exam you need to convince all judges by playing with them. You can play only one game with each judge. As a result of a particular game, you can divide the uncertainty of i-th judge by any natural divisor of a_i which is at most k. If GCD of all indicators is equal to 1, you will enter to the professional layer and become a judge.
Also, you want to minimize the total amount of spent time. So, if you play with x judges with total experience y you will spend x β
y seconds.
Print minimal time to enter to the professional layer or -1 if it's impossible.
Input
There are two numbers in the first line n and k (1 β€ n β€ 10^6, 1 β€ k β€ 10^{12}) β the number of judges and your skill in Cardbluff.
The second line contains n integers, where i-th number a_i (1 β€ a_i β€ 10^{12}) β the uncertainty of i-th judge
The third line contains n integers in the same format (1 β€ e_i β€ 10^9), e_i β the experience of i-th judge.
Output
Print the single integer β minimal number of seconds to pass exam, or -1 if it's impossible
Examples
Input
3 6
30 30 30
100 4 5
Output
18
Input
1 1000000
1
100
Output
0
Input
3 5
7 7 7
1 1 1
Output
-1
Submitted Solution:
```
import math
n,k=map(int,input().split())
a=list(map(int,input().split()))
e=list(map(int,input().split()))
e.sort()
big=a[0]
for i in range(n-1):
big=math.gcd(big,a[i+1])
if big==1:
break
if big==1:
print(0)
else:
factors=[]
for i in range(1,k+1):
if big%i==0:
factors.append(i)
ind=len(factors)-1
nums=[]
while True:
if ind==0:
break
if big==1:
break
if big%factors[ind]==0:
nums.append(factors[ind])
big//=factors[ind]
else:
ind-=1
if ind==0:
print(-1)
else:
j=len(nums)
if j>n:
print(-1)
else:
print(j*sum(e[:j]))
``` | instruction | 0 | 5,078 | 19 | 10,156 |
No | output | 1 | 5,078 | 19 | 10,157 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Cardbluff is popular sport game in Telegram. Each Cardbluff player has ever dreamed about entrance in the professional layer. There are n judges now in the layer and you are trying to pass the entrance exam. You have a number k β your skill in Cardbluff.
Each judge has a number a_i β an indicator of uncertainty about your entrance to the professional layer and a number e_i β an experience playing Cardbluff. To pass the exam you need to convince all judges by playing with them. You can play only one game with each judge. As a result of a particular game, you can divide the uncertainty of i-th judge by any natural divisor of a_i which is at most k. If GCD of all indicators is equal to 1, you will enter to the professional layer and become a judge.
Also, you want to minimize the total amount of spent time. So, if you play with x judges with total experience y you will spend x β
y seconds.
Print minimal time to enter to the professional layer or -1 if it's impossible.
Input
There are two numbers in the first line n and k (1 β€ n β€ 10^6, 1 β€ k β€ 10^{12}) β the number of judges and your skill in Cardbluff.
The second line contains n integers, where i-th number a_i (1 β€ a_i β€ 10^{12}) β the uncertainty of i-th judge
The third line contains n integers in the same format (1 β€ e_i β€ 10^9), e_i β the experience of i-th judge.
Output
Print the single integer β minimal number of seconds to pass exam, or -1 if it's impossible
Examples
Input
3 6
30 30 30
100 4 5
Output
18
Input
1 1000000
1
100
Output
0
Input
3 5
7 7 7
1 1 1
Output
-1
Submitted Solution:
```
import math
n,k=map(int,input().split())
a=list(map(int,input().split()))
e=list(map(int,input().split()))
e.sort()
big=a[0]
for i in range(n-1):
big=math.gcd(big,a[i+1])
if big==1:
break
if big==1:
print(0)
else:
factors=[]
for i in range(1,k+1):
if big%i==0:
factors.append(i)
ind=len(factors)-1
nums=[]
while True:
if ind==0:
break
if big==1:
break
if big%factors[ind]==0:
nums.append(factors[ind])
big//=factors[ind]
else:
ind-=1
if ind==0:
print(-1)
else:
j=len(nums)
print(j*sum(e[:j]))
``` | instruction | 0 | 5,079 | 19 | 10,158 |
No | output | 1 | 5,079 | 19 | 10,159 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Tokitsukaze is playing a game derivated from Japanese mahjong. In this game, she has three tiles in her hand. Each tile she owns is a suited tile, which means it has a suit (manzu, pinzu or souzu) and a number (a digit ranged from 1 to 9). In this problem, we use one digit and one lowercase letter, which is the first character of the suit, to represent a suited tile. All possible suited tiles are represented as 1m, 2m, β¦, 9m, 1p, 2p, β¦, 9p, 1s, 2s, β¦, 9s.
In order to win the game, she must have at least one mentsu (described below) in her hand, so sometimes she should draw extra suited tiles. After drawing a tile, the number of her tiles increases by one. She can draw any tiles she wants, including those already in her hand.
Do you know the minimum number of extra suited tiles she needs to draw so that she can win?
Here are some useful definitions in this game:
* A mentsu, also known as meld, is formed by a koutsu or a shuntsu;
* A koutsu, also known as triplet, is made of three identical tiles, such as [1m, 1m, 1m], however, [1m, 1p, 1s] or [1m, 4m, 7m] is NOT a koutsu;
* A shuntsu, also known as sequence, is made of three sequential numbered tiles in the same suit, such as [1m, 2m, 3m] and [5s, 7s, 6s], however, [9m, 1m, 2m] or [1m, 2p, 3s] is NOT a shuntsu.
Some examples:
* [2m, 3p, 2s, 4m, 1s, 2s, 4s] β it contains no koutsu or shuntsu, so it includes no mentsu;
* [4s, 3m, 3p, 4s, 5p, 4s, 5p] β it contains a koutsu, [4s, 4s, 4s], but no shuntsu, so it includes a mentsu;
* [5p, 5s, 9m, 4p, 1s, 7p, 7m, 6p] β it contains no koutsu but a shuntsu, [5p, 4p, 6p] or [5p, 7p, 6p], so it includes a mentsu.
Note that the order of tiles is unnecessary and you can assume the number of each type of suited tiles she can draw is infinite.
Input
The only line contains three strings β the tiles in Tokitsukaze's hand. For each string, the first character is a digit ranged from 1 to 9 and the second character is m, p or s.
Output
Print a single integer β the minimum number of extra suited tiles she needs to draw.
Examples
Input
1s 2s 3s
Output
0
Input
9m 9m 9m
Output
0
Input
3p 9m 2p
Output
1
Note
In the first example, Tokitsukaze already has a shuntsu.
In the second example, Tokitsukaze already has a koutsu.
In the third example, Tokitsukaze can get a shuntsu by drawing one suited tile β 1p or 4p. The resulting tiles will be [3p, 9m, 2p, 1p] or [3p, 9m, 2p, 4p]. | instruction | 0 | 5,103 | 19 | 10,206 |
Tags: brute force, implementation
Correct Solution:
```
from collections import defaultdict as dfd
d = dfd(int)
arr = input().split()
arr.sort()
for i in arr:
d[i] += 1
if max(d.values())==3 or (arr[0][1]==arr[1][1]==arr[2][1] and int(arr[0][0])+1==int(arr[1][0]) and int(arr[1][0])+1==int(arr[2][0])):
print(0)
elif max(d.values())==2:
print(1)
else:
flag = True
for i in range(len(arr)):
for j in range(i+1, len(arr)):
if arr[i][1]==arr[j][1] and (abs(int(arr[i][0])-int(arr[j][0]))==1 or abs(int(arr[i][0])-int(arr[j][0]))==2):
print(1)
flag = False
break
if not flag:
break
if flag:
print(2)
``` | output | 1 | 5,103 | 19 | 10,207 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Tokitsukaze is playing a game derivated from Japanese mahjong. In this game, she has three tiles in her hand. Each tile she owns is a suited tile, which means it has a suit (manzu, pinzu or souzu) and a number (a digit ranged from 1 to 9). In this problem, we use one digit and one lowercase letter, which is the first character of the suit, to represent a suited tile. All possible suited tiles are represented as 1m, 2m, β¦, 9m, 1p, 2p, β¦, 9p, 1s, 2s, β¦, 9s.
In order to win the game, she must have at least one mentsu (described below) in her hand, so sometimes she should draw extra suited tiles. After drawing a tile, the number of her tiles increases by one. She can draw any tiles she wants, including those already in her hand.
Do you know the minimum number of extra suited tiles she needs to draw so that she can win?
Here are some useful definitions in this game:
* A mentsu, also known as meld, is formed by a koutsu or a shuntsu;
* A koutsu, also known as triplet, is made of three identical tiles, such as [1m, 1m, 1m], however, [1m, 1p, 1s] or [1m, 4m, 7m] is NOT a koutsu;
* A shuntsu, also known as sequence, is made of three sequential numbered tiles in the same suit, such as [1m, 2m, 3m] and [5s, 7s, 6s], however, [9m, 1m, 2m] or [1m, 2p, 3s] is NOT a shuntsu.
Some examples:
* [2m, 3p, 2s, 4m, 1s, 2s, 4s] β it contains no koutsu or shuntsu, so it includes no mentsu;
* [4s, 3m, 3p, 4s, 5p, 4s, 5p] β it contains a koutsu, [4s, 4s, 4s], but no shuntsu, so it includes a mentsu;
* [5p, 5s, 9m, 4p, 1s, 7p, 7m, 6p] β it contains no koutsu but a shuntsu, [5p, 4p, 6p] or [5p, 7p, 6p], so it includes a mentsu.
Note that the order of tiles is unnecessary and you can assume the number of each type of suited tiles she can draw is infinite.
Input
The only line contains three strings β the tiles in Tokitsukaze's hand. For each string, the first character is a digit ranged from 1 to 9 and the second character is m, p or s.
Output
Print a single integer β the minimum number of extra suited tiles she needs to draw.
Examples
Input
1s 2s 3s
Output
0
Input
9m 9m 9m
Output
0
Input
3p 9m 2p
Output
1
Note
In the first example, Tokitsukaze already has a shuntsu.
In the second example, Tokitsukaze already has a koutsu.
In the third example, Tokitsukaze can get a shuntsu by drawing one suited tile β 1p or 4p. The resulting tiles will be [3p, 9m, 2p, 1p] or [3p, 9m, 2p, 4p]. | instruction | 0 | 5,104 | 19 | 10,208 |
Tags: brute force, implementation
Correct Solution:
```
a = sorted(list(map(lambda x: ord(x[0]) + 256 * ord(x[1]), input().split())))
res = 2
if a[1] - a[0] in [0, 1, 2] or a[2] - a[1] in [0, 1, 2]:
res = 1
if (a[0] == a[1] and a[1] == a[2]) or (a[0] + 1 == a[1] and a[1] + 1 == a[2]):
res = 0
print(res)
``` | output | 1 | 5,104 | 19 | 10,209 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Tokitsukaze is playing a game derivated from Japanese mahjong. In this game, she has three tiles in her hand. Each tile she owns is a suited tile, which means it has a suit (manzu, pinzu or souzu) and a number (a digit ranged from 1 to 9). In this problem, we use one digit and one lowercase letter, which is the first character of the suit, to represent a suited tile. All possible suited tiles are represented as 1m, 2m, β¦, 9m, 1p, 2p, β¦, 9p, 1s, 2s, β¦, 9s.
In order to win the game, she must have at least one mentsu (described below) in her hand, so sometimes she should draw extra suited tiles. After drawing a tile, the number of her tiles increases by one. She can draw any tiles she wants, including those already in her hand.
Do you know the minimum number of extra suited tiles she needs to draw so that she can win?
Here are some useful definitions in this game:
* A mentsu, also known as meld, is formed by a koutsu or a shuntsu;
* A koutsu, also known as triplet, is made of three identical tiles, such as [1m, 1m, 1m], however, [1m, 1p, 1s] or [1m, 4m, 7m] is NOT a koutsu;
* A shuntsu, also known as sequence, is made of three sequential numbered tiles in the same suit, such as [1m, 2m, 3m] and [5s, 7s, 6s], however, [9m, 1m, 2m] or [1m, 2p, 3s] is NOT a shuntsu.
Some examples:
* [2m, 3p, 2s, 4m, 1s, 2s, 4s] β it contains no koutsu or shuntsu, so it includes no mentsu;
* [4s, 3m, 3p, 4s, 5p, 4s, 5p] β it contains a koutsu, [4s, 4s, 4s], but no shuntsu, so it includes a mentsu;
* [5p, 5s, 9m, 4p, 1s, 7p, 7m, 6p] β it contains no koutsu but a shuntsu, [5p, 4p, 6p] or [5p, 7p, 6p], so it includes a mentsu.
Note that the order of tiles is unnecessary and you can assume the number of each type of suited tiles she can draw is infinite.
Input
The only line contains three strings β the tiles in Tokitsukaze's hand. For each string, the first character is a digit ranged from 1 to 9 and the second character is m, p or s.
Output
Print a single integer β the minimum number of extra suited tiles she needs to draw.
Examples
Input
1s 2s 3s
Output
0
Input
9m 9m 9m
Output
0
Input
3p 9m 2p
Output
1
Note
In the first example, Tokitsukaze already has a shuntsu.
In the second example, Tokitsukaze already has a koutsu.
In the third example, Tokitsukaze can get a shuntsu by drawing one suited tile β 1p or 4p. The resulting tiles will be [3p, 9m, 2p, 1p] or [3p, 9m, 2p, 4p]. | instruction | 0 | 5,105 | 19 | 10,210 |
Tags: brute force, implementation
Correct Solution:
```
x,y,z = input().split()
v = list((x,y,z))
v.sort()
#print(v)
a = int(v[0][0])
b = int(v[1][0])
c = int(v[2][0])
l = v[0][1]
m = v[1][1]
n = v[2][1]
#print(a,b,c,l,m,n)
if x==y and y==z:
print(0)
elif x==y and y!=z or x==z and y!=z or y==z and x!=z:
print(1)
else:
if l==m and m==n:
if b==a+1 and c==b+1:
print(0)
elif b==a+1 and c!=b+1 or c==b+1 and b!=a+1:
print(1)
elif b==a+2 or c==b+2:
print(1)
else:
print(2)
elif l==m and m!=n:
if b==a+1 or b==a+2 or b==a:
print(1)
else:
print(2)
elif m==n and l!=n:
if c==b+1 or c==b or c==b+2:
print(1)
else:
print(2)
elif l==n and n!=m:
if c==a+1 or c==a or c==a+2:
print(1)
else:
print(2)
else:
print(2)
``` | output | 1 | 5,105 | 19 | 10,211 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.