message stringlengths 2 39.6k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 450 109k | cluster float64 2 2 | __index_level_0__ int64 900 217k |
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Important: All possible tests are in the pretest, so you shouldn't hack on this problem. So, if you passed pretests, you will also pass the system test.
You are an adventurer currently journeying inside an evil temple. After defeating a couple of weak monsters, you arrived at a square room consisting of tiles forming an n × n grid, surrounded entirely by walls. At the end of the room lies a door locked with evil magical forces. The following inscriptions are written on the door:
The sound of clashing rocks will awaken the door!
Being a very senior adventurer, you immediately realize what this means. In the room next door lies an infinite number of magical rocks. There are four types of rocks:
* '^': this rock moves upwards;
* '<': this rock moves leftwards;
* '>': this rock moves rightwards;
* 'v': this rock moves downwards.
To open the door, you first need to place the rocks on some of the tiles (one tile can be occupied by at most one rock). Then, you select a single rock that you have placed and activate it. The activated rock will then move in its direction until it hits another rock or hits the walls of the room (the rock will not move if something already blocks it in its chosen direction). The rock then deactivates. If it hits the walls, or if there have been already 107 events of rock becoming activated, the movements end. Otherwise, the rock that was hit becomes activated and this procedure is repeated.
If a rock moves at least one cell before hitting either the wall or another rock, the hit produces a sound. The door will open once the number of produced sounds is at least x. It is okay for the rocks to continue moving after producing x sounds.
The following picture illustrates the four possible scenarios of moving rocks.
* Moves at least one cell, then hits another rock. A sound is produced, the hit rock becomes activated. <image>
* Moves at least one cell, then hits the wall (i.e., the side of the room). A sound is produced, the movements end. <image>
* Does not move because a rock is already standing in the path. The blocking rock becomes activated, but no sounds are produced. <image>
* Does not move because the wall is in the way. No sounds are produced and the movements end. <image>
Assume there's an infinite number of rocks of each type in the neighboring room. You know what to do: place the rocks and open the door!
Input
The first line will consists of two integers n and x, denoting the size of the room and the number of sounds required to open the door. There will be exactly three test cases for this problem:
* n = 5, x = 5;
* n = 3, x = 2;
* n = 100, x = 105.
All of these testcases are in pretest.
Output
Output n lines. Each line consists of n characters — the j-th character of the i-th line represents the content of the tile at the i-th row and the j-th column, and should be one of these:
* '^', '<', '>', or 'v': a rock as described in the problem statement.
* '.': an empty tile.
Then, output two integers r and c (1 ≤ r, c ≤ n) on the next line — this means that the rock you activate first is located at the r-th row from above and c-th column from the left. There must be a rock in this cell.
If there are multiple solutions, you may output any of them.
Examples
Input
5 5
Output
>...v
v.<..
..^..
>....
..^.<
1 1
Input
3 2
Output
>vv
^<.
^.<
1 3
Note
Here's a simulation of the first example, accompanied with the number of sounds produced so far.
<image> 0 sound <image> 1 sound <image> 2 sounds <image> 3 sounds <image> 4 sounds <image> still 4 sounds
In the picture above, the activated rock switches between the '^' rock and the '<' rock. However, no sound is produced since the '^' rock didn't move even a single tile. So, still 4 sound.
<image> 5 sounds
At this point, 5 sound are already produced, so this solution is already correct. However, for the sake of example, we will continue simulating what happens.
<image> 6 sounds <image> 7 sounds <image> still 7 sounds <image> 8 sounds
And the movement stops. In total, it produces 8 sounds. Notice that the last move produced sound.
Here's a simulation of the second example:
<image> 0 sound <image> 1 sound <image> 2 sounds
Now, the activated stone will switch continuously from one to another without producing a sound until it reaches the 107 limit, after which the movement will cease.
<image>
In total, it produced exactly 2 sounds, so the solution is correct.
Submitted Solution:
```
n=input()
if n[0]=='5':print(">.>.v\n.v.<.\n>.>^v\n.>.^.\n^.<.<\n1 1")
elif n[0]=='3':print(">.v\n>^.\n^.<\n1 1")
else:print(">"*34+".>"*32+".v\n"+("^."+"<."*32+"<"*33+"v\n"+">"*33+".>"*32+".^v\n")*16+("^."+"<."*32+"<"*33+"v\n"+">"*33+".>"*32+".^.\n")*33+"^."+"<."*32+"<"*34)
``` | instruction | 0 | 56,664 | 2 | 113,328 |
No | output | 1 | 56,664 | 2 | 113,329 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Important: All possible tests are in the pretest, so you shouldn't hack on this problem. So, if you passed pretests, you will also pass the system test.
You are an adventurer currently journeying inside an evil temple. After defeating a couple of weak monsters, you arrived at a square room consisting of tiles forming an n × n grid, surrounded entirely by walls. At the end of the room lies a door locked with evil magical forces. The following inscriptions are written on the door:
The sound of clashing rocks will awaken the door!
Being a very senior adventurer, you immediately realize what this means. In the room next door lies an infinite number of magical rocks. There are four types of rocks:
* '^': this rock moves upwards;
* '<': this rock moves leftwards;
* '>': this rock moves rightwards;
* 'v': this rock moves downwards.
To open the door, you first need to place the rocks on some of the tiles (one tile can be occupied by at most one rock). Then, you select a single rock that you have placed and activate it. The activated rock will then move in its direction until it hits another rock or hits the walls of the room (the rock will not move if something already blocks it in its chosen direction). The rock then deactivates. If it hits the walls, or if there have been already 107 events of rock becoming activated, the movements end. Otherwise, the rock that was hit becomes activated and this procedure is repeated.
If a rock moves at least one cell before hitting either the wall or another rock, the hit produces a sound. The door will open once the number of produced sounds is at least x. It is okay for the rocks to continue moving after producing x sounds.
The following picture illustrates the four possible scenarios of moving rocks.
* Moves at least one cell, then hits another rock. A sound is produced, the hit rock becomes activated. <image>
* Moves at least one cell, then hits the wall (i.e., the side of the room). A sound is produced, the movements end. <image>
* Does not move because a rock is already standing in the path. The blocking rock becomes activated, but no sounds are produced. <image>
* Does not move because the wall is in the way. No sounds are produced and the movements end. <image>
Assume there's an infinite number of rocks of each type in the neighboring room. You know what to do: place the rocks and open the door!
Input
The first line will consists of two integers n and x, denoting the size of the room and the number of sounds required to open the door. There will be exactly three test cases for this problem:
* n = 5, x = 5;
* n = 3, x = 2;
* n = 100, x = 105.
All of these testcases are in pretest.
Output
Output n lines. Each line consists of n characters — the j-th character of the i-th line represents the content of the tile at the i-th row and the j-th column, and should be one of these:
* '^', '<', '>', or 'v': a rock as described in the problem statement.
* '.': an empty tile.
Then, output two integers r and c (1 ≤ r, c ≤ n) on the next line — this means that the rock you activate first is located at the r-th row from above and c-th column from the left. There must be a rock in this cell.
If there are multiple solutions, you may output any of them.
Examples
Input
5 5
Output
>...v
v.<..
..^..
>....
..^.<
1 1
Input
3 2
Output
>vv
^<.
^.<
1 3
Note
Here's a simulation of the first example, accompanied with the number of sounds produced so far.
<image> 0 sound <image> 1 sound <image> 2 sounds <image> 3 sounds <image> 4 sounds <image> still 4 sounds
In the picture above, the activated rock switches between the '^' rock and the '<' rock. However, no sound is produced since the '^' rock didn't move even a single tile. So, still 4 sound.
<image> 5 sounds
At this point, 5 sound are already produced, so this solution is already correct. However, for the sake of example, we will continue simulating what happens.
<image> 6 sounds <image> 7 sounds <image> still 7 sounds <image> 8 sounds
And the movement stops. In total, it produces 8 sounds. Notice that the last move produced sound.
Here's a simulation of the second example:
<image> 0 sound <image> 1 sound <image> 2 sounds
Now, the activated stone will switch continuously from one to another without producing a sound until it reaches the 107 limit, after which the movement will cease.
<image>
In total, it produced exactly 2 sounds, so the solution is correct.
Submitted Solution:
```
r, c = map(int, input().split())
if r == 3:
print('>vv')
print('^<.')
print('^.<')
print('1 3')
elif r == 5:
print('>...v')
print('v.<..')
print('..^..')
print('>....')
print('..^.<')
print('1 1')
elif r == 100:
for i in range(25):
print('>'*50+' >'*24+' v')
print('^'+'< '*25+'<'*49)
print('v '+'< '*24+'<'*50)
print('>'*49+' >'*25+'^')
print('1 1')
``` | instruction | 0 | 56,665 | 2 | 113,330 |
No | output | 1 | 56,665 | 2 | 113,331 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Important: All possible tests are in the pretest, so you shouldn't hack on this problem. So, if you passed pretests, you will also pass the system test.
You are an adventurer currently journeying inside an evil temple. After defeating a couple of weak monsters, you arrived at a square room consisting of tiles forming an n × n grid, surrounded entirely by walls. At the end of the room lies a door locked with evil magical forces. The following inscriptions are written on the door:
The sound of clashing rocks will awaken the door!
Being a very senior adventurer, you immediately realize what this means. In the room next door lies an infinite number of magical rocks. There are four types of rocks:
* '^': this rock moves upwards;
* '<': this rock moves leftwards;
* '>': this rock moves rightwards;
* 'v': this rock moves downwards.
To open the door, you first need to place the rocks on some of the tiles (one tile can be occupied by at most one rock). Then, you select a single rock that you have placed and activate it. The activated rock will then move in its direction until it hits another rock or hits the walls of the room (the rock will not move if something already blocks it in its chosen direction). The rock then deactivates. If it hits the walls, or if there have been already 107 events of rock becoming activated, the movements end. Otherwise, the rock that was hit becomes activated and this procedure is repeated.
If a rock moves at least one cell before hitting either the wall or another rock, the hit produces a sound. The door will open once the number of produced sounds is at least x. It is okay for the rocks to continue moving after producing x sounds.
The following picture illustrates the four possible scenarios of moving rocks.
* Moves at least one cell, then hits another rock. A sound is produced, the hit rock becomes activated. <image>
* Moves at least one cell, then hits the wall (i.e., the side of the room). A sound is produced, the movements end. <image>
* Does not move because a rock is already standing in the path. The blocking rock becomes activated, but no sounds are produced. <image>
* Does not move because the wall is in the way. No sounds are produced and the movements end. <image>
Assume there's an infinite number of rocks of each type in the neighboring room. You know what to do: place the rocks and open the door!
Input
The first line will consists of two integers n and x, denoting the size of the room and the number of sounds required to open the door. There will be exactly three test cases for this problem:
* n = 5, x = 5;
* n = 3, x = 2;
* n = 100, x = 105.
All of these testcases are in pretest.
Output
Output n lines. Each line consists of n characters — the j-th character of the i-th line represents the content of the tile at the i-th row and the j-th column, and should be one of these:
* '^', '<', '>', or 'v': a rock as described in the problem statement.
* '.': an empty tile.
Then, output two integers r and c (1 ≤ r, c ≤ n) on the next line — this means that the rock you activate first is located at the r-th row from above and c-th column from the left. There must be a rock in this cell.
If there are multiple solutions, you may output any of them.
Examples
Input
5 5
Output
>...v
v.<..
..^..
>....
..^.<
1 1
Input
3 2
Output
>vv
^<.
^.<
1 3
Note
Here's a simulation of the first example, accompanied with the number of sounds produced so far.
<image> 0 sound <image> 1 sound <image> 2 sounds <image> 3 sounds <image> 4 sounds <image> still 4 sounds
In the picture above, the activated rock switches between the '^' rock and the '<' rock. However, no sound is produced since the '^' rock didn't move even a single tile. So, still 4 sound.
<image> 5 sounds
At this point, 5 sound are already produced, so this solution is already correct. However, for the sake of example, we will continue simulating what happens.
<image> 6 sounds <image> 7 sounds <image> still 7 sounds <image> 8 sounds
And the movement stops. In total, it produces 8 sounds. Notice that the last move produced sound.
Here's a simulation of the second example:
<image> 0 sound <image> 1 sound <image> 2 sounds
Now, the activated stone will switch continuously from one to another without producing a sound until it reaches the 107 limit, after which the movement will cease.
<image>
In total, it produced exactly 2 sounds, so the solution is correct.
Submitted Solution:
```
n=input()
if n[0]=='5':print(">.>.v\n.v.<.\n>.>^v\n.>.^.\n^.<.<\n1 1")
elif n[0]=='3':print(">.v\n>^.\n^.<\n1 1")
else:print(">"*50+".>"*24+".v\n"+("^."+"<."*24+"<"*49+"v\n"+">"*49+".>"*24+".^v\n")*16+("^."+"<."*24+"<"*49+"v\n"+">"*49+".>"*24+".^.\n")*33+"^."+"<."*24+"<"*50+"\n1 1")
``` | instruction | 0 | 56,666 | 2 | 113,332 |
No | output | 1 | 56,666 | 2 | 113,333 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Important: All possible tests are in the pretest, so you shouldn't hack on this problem. So, if you passed pretests, you will also pass the system test.
You are an adventurer currently journeying inside an evil temple. After defeating a couple of weak monsters, you arrived at a square room consisting of tiles forming an n × n grid, surrounded entirely by walls. At the end of the room lies a door locked with evil magical forces. The following inscriptions are written on the door:
The sound of clashing rocks will awaken the door!
Being a very senior adventurer, you immediately realize what this means. In the room next door lies an infinite number of magical rocks. There are four types of rocks:
* '^': this rock moves upwards;
* '<': this rock moves leftwards;
* '>': this rock moves rightwards;
* 'v': this rock moves downwards.
To open the door, you first need to place the rocks on some of the tiles (one tile can be occupied by at most one rock). Then, you select a single rock that you have placed and activate it. The activated rock will then move in its direction until it hits another rock or hits the walls of the room (the rock will not move if something already blocks it in its chosen direction). The rock then deactivates. If it hits the walls, or if there have been already 107 events of rock becoming activated, the movements end. Otherwise, the rock that was hit becomes activated and this procedure is repeated.
If a rock moves at least one cell before hitting either the wall or another rock, the hit produces a sound. The door will open once the number of produced sounds is at least x. It is okay for the rocks to continue moving after producing x sounds.
The following picture illustrates the four possible scenarios of moving rocks.
* Moves at least one cell, then hits another rock. A sound is produced, the hit rock becomes activated. <image>
* Moves at least one cell, then hits the wall (i.e., the side of the room). A sound is produced, the movements end. <image>
* Does not move because a rock is already standing in the path. The blocking rock becomes activated, but no sounds are produced. <image>
* Does not move because the wall is in the way. No sounds are produced and the movements end. <image>
Assume there's an infinite number of rocks of each type in the neighboring room. You know what to do: place the rocks and open the door!
Input
The first line will consists of two integers n and x, denoting the size of the room and the number of sounds required to open the door. There will be exactly three test cases for this problem:
* n = 5, x = 5;
* n = 3, x = 2;
* n = 100, x = 105.
All of these testcases are in pretest.
Output
Output n lines. Each line consists of n characters — the j-th character of the i-th line represents the content of the tile at the i-th row and the j-th column, and should be one of these:
* '^', '<', '>', or 'v': a rock as described in the problem statement.
* '.': an empty tile.
Then, output two integers r and c (1 ≤ r, c ≤ n) on the next line — this means that the rock you activate first is located at the r-th row from above and c-th column from the left. There must be a rock in this cell.
If there are multiple solutions, you may output any of them.
Examples
Input
5 5
Output
>...v
v.<..
..^..
>....
..^.<
1 1
Input
3 2
Output
>vv
^<.
^.<
1 3
Note
Here's a simulation of the first example, accompanied with the number of sounds produced so far.
<image> 0 sound <image> 1 sound <image> 2 sounds <image> 3 sounds <image> 4 sounds <image> still 4 sounds
In the picture above, the activated rock switches between the '^' rock and the '<' rock. However, no sound is produced since the '^' rock didn't move even a single tile. So, still 4 sound.
<image> 5 sounds
At this point, 5 sound are already produced, so this solution is already correct. However, for the sake of example, we will continue simulating what happens.
<image> 6 sounds <image> 7 sounds <image> still 7 sounds <image> 8 sounds
And the movement stops. In total, it produces 8 sounds. Notice that the last move produced sound.
Here's a simulation of the second example:
<image> 0 sound <image> 1 sound <image> 2 sounds
Now, the activated stone will switch continuously from one to another without producing a sound until it reaches the 107 limit, after which the movement will cease.
<image>
In total, it produced exactly 2 sounds, so the solution is correct.
Submitted Solution:
```
r, c = map(int, input().split())
if r == 3:
print('>vv')
print('^<.')
print('^.<')
print('1 3')
elif r == 5:
print('>...v')
print('v.<..')
print('..^..')
print('>....')
print('..^.<')
print('1 1')
elif r == 100:
for i in range(25):
print('>'*50+' >'*24+' v')
print('^'+'< '*25+'<'*49)
print('v '+'< '*24+'<'*50)
print('>'*49+' >'*25+'^')
print('1 1')
else:
d = []
d[1] = 1
``` | instruction | 0 | 56,667 | 2 | 113,334 |
No | output | 1 | 56,667 | 2 | 113,335 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are playing a computer card game called Splay the Sire. Currently you are struggling to defeat the final boss of the game.
The boss battle consists of n turns. During each turn, you will get several cards. Each card has two parameters: its cost c_i and damage d_i. You may play some of your cards during each turn in some sequence (you choose the cards and the exact order they are played), as long as the total cost of the cards you play during the turn does not exceed 3. After playing some (possibly zero) cards, you end your turn, and all cards you didn't play are discarded. Note that you can use each card at most once.
Your character has also found an artifact that boosts the damage of some of your actions: every 10-th card you play deals double damage.
What is the maximum possible damage you can deal during n turns?
Input
The first line contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of turns.
Then n blocks of input follow, the i-th block representing the cards you get during the i-th turn.
Each block begins with a line containing one integer k_i (1 ≤ k_i ≤ 2 ⋅ 10^5) — the number of cards you get during i-th turn. Then k_i lines follow, each containing two integers c_j and d_j (1 ≤ c_j ≤ 3, 1 ≤ d_j ≤ 10^9) — the parameters of the corresponding card.
It is guaranteed that ∑ _{i = 1}^{n} k_i ≤ 2 ⋅ 10^5.
Output
Print one integer — the maximum damage you may deal.
Example
Input
5
3
1 6
1 7
1 5
2
1 4
1 3
3
1 10
3 5
2 3
3
1 15
2 4
1 10
1
1 100
Output
263
Note
In the example test the best course of action is as follows:
During the first turn, play all three cards in any order and deal 18 damage.
During the second turn, play both cards and deal 7 damage.
During the third turn, play the first and the third card and deal 13 damage.
During the fourth turn, play the first and the third card and deal 25 damage.
During the fifth turn, play the only card, which will deal double damage (200). | instruction | 0 | 57,228 | 2 | 114,456 |
Tags: dp, implementation, sortings
Correct Solution:
```
import sys
import math
import cProfile
DEBUG = False
def log(s):
if DEBUG and False:
print(s)
def calc_dmg(num, arr):
maximum = 0
if num - len(arr) < 0:
maximum = max(arr)
return sum(arr) + maximum
if DEBUG:
sys.stdin = open('input.txt')
pr = cProfile.Profile()
pr.enable()
n = sys.stdin.readline()
n = int(n)
dmg = [-sys.maxsize for _ in range(10)]
for i in range(n):
log(dmg)
cards = [_[:] for _ in [[-sys.maxsize] * 3] * 4]
k = sys.stdin.readline()
k = int(k)
for _ in range(k):
c, d = sys.stdin.readline().split()
c = int(c)
d = int(d)
cards[c].append(d)
cards[1].sort(reverse=True)
cards[2].sort(reverse=True)
cards[3].sort(reverse=True)
log(cards)
# dmg[j] = max(dmg[j],
# dmg[j - 1] + D(one card),
# dmg[j - 2] + D(two cards),
# dmg[j - 3] + D(three cards))
# Plus, if 1 <= j <= 3, dmg[j] = max(dmg[j], D(cards))
new_dmg = []
for j in range(10):
use1 = max(cards[1][0], cards[2][0], cards[3][0])
use2 = max(cards[1][0] + cards[1][1],
cards[1][0] + cards[2][0])
use3 = cards[1][0] + cards[1][1] + cards[1][2]
maximum = dmg[j]
if use1 > 0:
maximum = max(maximum, dmg[j - 1] + calc_dmg(j, [use1]))
if j == 1:
maximum = max(maximum, use1)
if use2 > 0:
maximum = max(maximum, dmg[j - 2] +
calc_dmg(j, [cards[1][0], cards[1][1]]
if cards[1][0] + cards[1][1] == use2
else [cards[1][0], cards[2][0]]))
if j == 2:
maximum = max(maximum, use2)
if use3 > 0:
maximum = max(maximum, dmg[j - 3] +
calc_dmg(j, [cards[1][0], cards[1][1], cards[1][2]]))
if j == 3:
maximum = max(maximum, use3)
new_dmg.append(maximum)
dmg = new_dmg
log(dmg)
print(max(dmg))
if DEBUG:
pr.disable()
pr.print_stats()
``` | output | 1 | 57,228 | 2 | 114,457 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are playing a computer card game called Splay the Sire. Currently you are struggling to defeat the final boss of the game.
The boss battle consists of n turns. During each turn, you will get several cards. Each card has two parameters: its cost c_i and damage d_i. You may play some of your cards during each turn in some sequence (you choose the cards and the exact order they are played), as long as the total cost of the cards you play during the turn does not exceed 3. After playing some (possibly zero) cards, you end your turn, and all cards you didn't play are discarded. Note that you can use each card at most once.
Your character has also found an artifact that boosts the damage of some of your actions: every 10-th card you play deals double damage.
What is the maximum possible damage you can deal during n turns?
Input
The first line contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of turns.
Then n blocks of input follow, the i-th block representing the cards you get during the i-th turn.
Each block begins with a line containing one integer k_i (1 ≤ k_i ≤ 2 ⋅ 10^5) — the number of cards you get during i-th turn. Then k_i lines follow, each containing two integers c_j and d_j (1 ≤ c_j ≤ 3, 1 ≤ d_j ≤ 10^9) — the parameters of the corresponding card.
It is guaranteed that ∑ _{i = 1}^{n} k_i ≤ 2 ⋅ 10^5.
Output
Print one integer — the maximum damage you may deal.
Example
Input
5
3
1 6
1 7
1 5
2
1 4
1 3
3
1 10
3 5
2 3
3
1 15
2 4
1 10
1
1 100
Output
263
Note
In the example test the best course of action is as follows:
During the first turn, play all three cards in any order and deal 18 damage.
During the second turn, play both cards and deal 7 damage.
During the third turn, play the first and the third card and deal 13 damage.
During the fourth turn, play the first and the third card and deal 25 damage.
During the fifth turn, play the only card, which will deal double damage (200). | instruction | 0 | 57,229 | 2 | 114,458 |
Tags: dp, implementation, sortings
Correct Solution:
```
from sys import stdin, stdout, exit
n = int(input())
inf = 10**18
dp = [[-inf]*10 for i in range(n+1)]
dp[0][0] = 0
for i in range(n):
k = int(stdin.readline())
cards = []
for j in range(k):
c, d = map(int, stdin.readline().split())
cards.append((c, d))
cards.sort(reverse=True)
cards_by_cost = [[] for i in range(3)]
for c,d in cards:
cards_by_cost[c-1].append(d)
# print(cards_by_cost)
for j in range(3):
cards_by_cost[j] = cards_by_cost[j][:3]
for prev_played in range(10):
val = dp[i][prev_played]
dp[i+1][prev_played] = max(dp[i+1][prev_played], val)
for num_played in range(len(cards_by_cost[0])):
pld = num_played+prev_played+1
if pld >= 10:
dp[i+1][pld%10] = max(dp[i+1][pld%10], val + sum(cards_by_cost[0][:num_played+1]) + cards_by_cost[0][0])
else:
dp[i+1][pld] = max(dp[i+1][pld], val + sum(cards_by_cost[0][:num_played+1]))
if len(cards_by_cost[1]) > 0 and len(cards_by_cost[0]) > 0:
pld = 2 + prev_played
c0 = cards_by_cost[0][0]
c1 = cards_by_cost[1][0]
if pld >= 10:
dp[i+1][pld%10] = max(dp[i+1][pld%10], val + c0 + c1+ max(c0, c1))
else:
dp[i+1][pld] = max(dp[i+1][pld], val+c0+c1)
if len(cards_by_cost[1]) > 0:
pld = 1+prev_played
if pld >= 10:
dp[i+1][pld%10] = max(dp[i+1][pld%10], val+2*cards_by_cost[1][0])
else:
dp[i+1][pld] = max(dp[i+1][pld], val + cards_by_cost[1][0])
if len(cards_by_cost[2]) > 0:
pld=1+prev_played
if pld >= 10:
dp[i+1][pld%10] = max(dp[i+1][pld%10], val+2*cards_by_cost[2][0])
else:
dp[i+1][pld] = max(dp[i+1][pld], val + cards_by_cost[2][0])
ans = max(dp[n][i] for i in range(10))
stdout.write(str(ans) + "\n")
``` | output | 1 | 57,229 | 2 | 114,459 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are playing a computer card game called Splay the Sire. Currently you are struggling to defeat the final boss of the game.
The boss battle consists of n turns. During each turn, you will get several cards. Each card has two parameters: its cost c_i and damage d_i. You may play some of your cards during each turn in some sequence (you choose the cards and the exact order they are played), as long as the total cost of the cards you play during the turn does not exceed 3. After playing some (possibly zero) cards, you end your turn, and all cards you didn't play are discarded. Note that you can use each card at most once.
Your character has also found an artifact that boosts the damage of some of your actions: every 10-th card you play deals double damage.
What is the maximum possible damage you can deal during n turns?
Input
The first line contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of turns.
Then n blocks of input follow, the i-th block representing the cards you get during the i-th turn.
Each block begins with a line containing one integer k_i (1 ≤ k_i ≤ 2 ⋅ 10^5) — the number of cards you get during i-th turn. Then k_i lines follow, each containing two integers c_j and d_j (1 ≤ c_j ≤ 3, 1 ≤ d_j ≤ 10^9) — the parameters of the corresponding card.
It is guaranteed that ∑ _{i = 1}^{n} k_i ≤ 2 ⋅ 10^5.
Output
Print one integer — the maximum damage you may deal.
Example
Input
5
3
1 6
1 7
1 5
2
1 4
1 3
3
1 10
3 5
2 3
3
1 15
2 4
1 10
1
1 100
Output
263
Note
In the example test the best course of action is as follows:
During the first turn, play all three cards in any order and deal 18 damage.
During the second turn, play both cards and deal 7 damage.
During the third turn, play the first and the third card and deal 13 damage.
During the fourth turn, play the first and the third card and deal 25 damage.
During the fifth turn, play the only card, which will deal double damage (200).
Submitted Solution:
```
import sys
import math
import cProfile
DEBUG = False
def log(s):
if DEBUG and False:
print(s)
def calc_dmg(num, arr):
maximum = 0
if num - len(arr) < 0:
maximum = max(arr)
return sum(arr) + maximum
if DEBUG:
sys.stdin = open('input.txt')
pr = cProfile.Profile()
pr.enable()
n = sys.stdin.readline()
n = int(n)
dmg = [-sys.maxsize for _ in range(10)]
for i in range(n):
log(dmg)
cards = [_[:] for _ in [[-sys.maxsize] * 3] * 4]
k = sys.stdin.readline()
k = int(k)
for _ in range(k):
c, d = sys.stdin.readline().split()
c = int(c)
d = int(d)
cards[c].append(d)
cards[1].sort(reverse=True)
cards[2].sort(reverse=True)
cards[3].sort(reverse=True)
log(cards)
new_dmg = []
for j in range(9, -1, -1):
use1 = max(cards[1][0], cards[2][0], cards[3][0])
use2 = max(cards[1][0] + cards[1][1],
cards[1][0] + cards[2][0])
use3 = cards[1][0] + cards[1][1] + cards[1][2]
maximum = 0
if use1 > 0:
maximum = (dmg[j - 1] if dmg[j - 1] > 0 else 0) + calc_dmg(j, [use1])
if use2 > 0:
maximum = max(maximum, (dmg[j - 2] if dmg[j - 2] > 0 else 0) +
calc_dmg(j, [cards[1][0], cards[1][1]]
if cards[1][0] + cards[1][1] == use2
else [cards[1][0], cards[2][0]]))
if use3 > 0:
maximum = max(maximum, (dmg[j - 3] if dmg[j - 3] > 0 else 0) +
calc_dmg(j, [cards[1][0], cards[1][1], cards[1][2]]))
new_dmg.append(maximum)
dmg = new_dmg
log(dmg)
print(max(dmg))
if DEBUG:
pr.disable()
pr.print_stats()
``` | instruction | 0 | 57,230 | 2 | 114,460 |
No | output | 1 | 57,230 | 2 | 114,461 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are playing a computer card game called Splay the Sire. Currently you are struggling to defeat the final boss of the game.
The boss battle consists of n turns. During each turn, you will get several cards. Each card has two parameters: its cost c_i and damage d_i. You may play some of your cards during each turn in some sequence (you choose the cards and the exact order they are played), as long as the total cost of the cards you play during the turn does not exceed 3. After playing some (possibly zero) cards, you end your turn, and all cards you didn't play are discarded. Note that you can use each card at most once.
Your character has also found an artifact that boosts the damage of some of your actions: every 10-th card you play deals double damage.
What is the maximum possible damage you can deal during n turns?
Input
The first line contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of turns.
Then n blocks of input follow, the i-th block representing the cards you get during the i-th turn.
Each block begins with a line containing one integer k_i (1 ≤ k_i ≤ 2 ⋅ 10^5) — the number of cards you get during i-th turn. Then k_i lines follow, each containing two integers c_j and d_j (1 ≤ c_j ≤ 3, 1 ≤ d_j ≤ 10^9) — the parameters of the corresponding card.
It is guaranteed that ∑ _{i = 1}^{n} k_i ≤ 2 ⋅ 10^5.
Output
Print one integer — the maximum damage you may deal.
Example
Input
5
3
1 6
1 7
1 5
2
1 4
1 3
3
1 10
3 5
2 3
3
1 15
2 4
1 10
1
1 100
Output
263
Note
In the example test the best course of action is as follows:
During the first turn, play all three cards in any order and deal 18 damage.
During the second turn, play both cards and deal 7 damage.
During the third turn, play the first and the third card and deal 13 damage.
During the fourth turn, play the first and the third card and deal 25 damage.
During the fifth turn, play the only card, which will deal double damage (200).
Submitted Solution:
```
def main():
t=int(input())
r=[]
for _ in range(t):
s=int(input())
wt=[]
val=[]
for _ in range(s):
m,n=map(int,input().split())
wt.append(m)
val.append(n)
n=s
w=s
dp=[]
for i in range(n+1):
dp.append([None]*(w+1))
for i in range(n + 1):
for j in range(w + 1):
if i==0 or j==0:
dp[i][j]=0
for i in range(1, n + 1):
for j in range(1, w + 1):
if wt[i-1]<=j:
dp[i][j] = max((val[i-1]+dp[i-1][j-wt[i-1]]), dp[i-1][j])
else:
dp[i][j]=dp[i-1][j]
res=dp[n][w]
for i in range(n, 0, -1):
if res <= 0:
break
if res == dp[i - 1][w]:
continue
else:
r.append(val[i - 1])
res = res - val[i - 1]
w = w - wt[i - 1]
sum=0
for i in range(len(r)):
if (i+1)%10==0:
sum+=2*r[i]
else:
sum+=r[i]
print(sum)
main()
``` | instruction | 0 | 57,231 | 2 | 114,462 |
No | output | 1 | 57,231 | 2 | 114,463 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are playing a computer card game called Splay the Sire. Currently you are struggling to defeat the final boss of the game.
The boss battle consists of n turns. During each turn, you will get several cards. Each card has two parameters: its cost c_i and damage d_i. You may play some of your cards during each turn in some sequence (you choose the cards and the exact order they are played), as long as the total cost of the cards you play during the turn does not exceed 3. After playing some (possibly zero) cards, you end your turn, and all cards you didn't play are discarded. Note that you can use each card at most once.
Your character has also found an artifact that boosts the damage of some of your actions: every 10-th card you play deals double damage.
What is the maximum possible damage you can deal during n turns?
Input
The first line contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of turns.
Then n blocks of input follow, the i-th block representing the cards you get during the i-th turn.
Each block begins with a line containing one integer k_i (1 ≤ k_i ≤ 2 ⋅ 10^5) — the number of cards you get during i-th turn. Then k_i lines follow, each containing two integers c_j and d_j (1 ≤ c_j ≤ 3, 1 ≤ d_j ≤ 10^9) — the parameters of the corresponding card.
It is guaranteed that ∑ _{i = 1}^{n} k_i ≤ 2 ⋅ 10^5.
Output
Print one integer — the maximum damage you may deal.
Example
Input
5
3
1 6
1 7
1 5
2
1 4
1 3
3
1 10
3 5
2 3
3
1 15
2 4
1 10
1
1 100
Output
263
Note
In the example test the best course of action is as follows:
During the first turn, play all three cards in any order and deal 18 damage.
During the second turn, play both cards and deal 7 damage.
During the third turn, play the first and the third card and deal 13 damage.
During the fourth turn, play the first and the third card and deal 25 damage.
During the fifth turn, play the only card, which will deal double damage (200).
Submitted Solution:
```
turns = int(input())
totalDamage = 0
cardCounter = 0
next10th = 10
for turn in range(turns):
cards = int(input())
ratioArr = {}; costArr = []; damageArr = []
for card in range(cards):
cost, damage = list(map(int,input().split()))
costArr.append(cost)
damageArr.append(damage)
ratioArr[card] = (damage/cost)
# print(ratioArr)
sortedRatioArr = sorted(ratioArr.items(), key=lambda kv: kv[1], reverse=True)
# print(sortedRatioArr)
tempTurnArr = []
totalCost = 0
ratioIdx = 0
for ratioIdx in range(cards):
idx = sortedRatioArr[ratioIdx][0]
totalCost += costArr[idx]
if totalCost<=3:
tempTurnArr.append(damageArr[idx])
else:
totalCost-= costArr[idx]
if (cardCounter+len(tempTurnArr)>next10th):
artefactIdx = (next10th - cardCounter - 1)
tempTurnArr[0] , tempTurnArr[artefactIdx] = tempTurnArr[artefactIdx] , tempTurnArr[0]
tempTurnArr[artefactIdx] *= 2
next10th+=10
totalDamage += sum(tempTurnArr)
cardCounter+=len(tempTurnArr)
print(totalDamage)
# if (cardCounter+1)%10==0:
# totalDamage += 2*damageArr[idx]
# else:
# totalDamage += damageArr[idx]
``` | instruction | 0 | 57,232 | 2 | 114,464 |
No | output | 1 | 57,232 | 2 | 114,465 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are playing a computer card game called Splay the Sire. Currently you are struggling to defeat the final boss of the game.
The boss battle consists of n turns. During each turn, you will get several cards. Each card has two parameters: its cost c_i and damage d_i. You may play some of your cards during each turn in some sequence (you choose the cards and the exact order they are played), as long as the total cost of the cards you play during the turn does not exceed 3. After playing some (possibly zero) cards, you end your turn, and all cards you didn't play are discarded. Note that you can use each card at most once.
Your character has also found an artifact that boosts the damage of some of your actions: every 10-th card you play deals double damage.
What is the maximum possible damage you can deal during n turns?
Input
The first line contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of turns.
Then n blocks of input follow, the i-th block representing the cards you get during the i-th turn.
Each block begins with a line containing one integer k_i (1 ≤ k_i ≤ 2 ⋅ 10^5) — the number of cards you get during i-th turn. Then k_i lines follow, each containing two integers c_j and d_j (1 ≤ c_j ≤ 3, 1 ≤ d_j ≤ 10^9) — the parameters of the corresponding card.
It is guaranteed that ∑ _{i = 1}^{n} k_i ≤ 2 ⋅ 10^5.
Output
Print one integer — the maximum damage you may deal.
Example
Input
5
3
1 6
1 7
1 5
2
1 4
1 3
3
1 10
3 5
2 3
3
1 15
2 4
1 10
1
1 100
Output
263
Note
In the example test the best course of action is as follows:
During the first turn, play all three cards in any order and deal 18 damage.
During the second turn, play both cards and deal 7 damage.
During the third turn, play the first and the third card and deal 13 damage.
During the fourth turn, play the first and the third card and deal 25 damage.
During the fifth turn, play the only card, which will deal double damage (200).
Submitted Solution:
```
from itertools import permutations
import sys
inf = float("inf")
def input(): return sys.stdin.readline()
def main():
n = int(input())
cards = [[] for i in range(n)]
for i in range(n):
k = int(input())
group = [[] for i in range(3)]
for j in range(k):
cost, damage = map(int, input().split())
group[cost-1].append(damage)
for j in range(3):
group[j].sort(reverse=True)
if j == 0:
for p in range(min(3, len(group[j]))):
cards[i].append((j+1, group[j][p]))
else:
for p in range(min(1, len(group[j]))):
cards[i].append((j+1, group[j][p]))
dp = [[-inf]*(10) for i in range(n+1)]
dp[0][0] = 0
for i in range(n):
L = len(cards[i])
subdp = [[0]*(2) for _ in range(4)]
for v in permutations(cards[i]):
total_cost = 0
total_add = 0
for j in range(L):
cst, dmg = v[j]
total_cost += cst
total_add += dmg
if total_cost > 3:
break
subdp[j+1][0] = max(subdp[j+1][0], total_add)
subdp[j+1][1] = max(subdp[j+1][1], total_add + dmg)
for j in range(10):
for k in range(4):
mod = (j+k) % 10
if mod > 0:
dp[i+1][mod] = max(dp[i+1][mod], dp[i][j]+subdp[k][0])
else:
dp[i+1][mod] = max(dp[i+1][mod], dp[i][j]+subdp[k][1])
ans = max(dp[n][mod] for mod in range(10))
print(ans)
return
if __name__ == "__main__":
main()
``` | instruction | 0 | 57,233 | 2 | 114,466 |
No | output | 1 | 57,233 | 2 | 114,467 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Being stuck at home, Ray became extremely bored. To pass time, he asks Lord Omkar to use his time bending power: Infinity Clock! However, Lord Omkar will only listen to mortals who can solve the following problem:
You are given an array a of n integers. You are also given an integer k. Lord Omkar wants you to do k operations with this array.
Define one operation as the following:
1. Set d to be the maximum value of your array.
2. For every i from 1 to n, replace a_{i} with d-a_{i}.
The goal is to predict the contents in the array after k operations. Please help Ray determine what the final sequence will look like!
Input
Each test contains multiple test cases. The first line contains the number of cases t (1 ≤ t ≤ 100). Description of the test cases follows.
The first line of each test case contains two integers n and k (1 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ k ≤ 10^{18}) – the length of your array and the number of operations to perform.
The second line of each test case contains n integers a_{1},a_{2},...,a_{n} (-10^9 ≤ a_{i} ≤ 10^9) – the initial contents of your array.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each case, print the final version of array a after k operations described above.
Example
Input
3
2 1
-199 192
5 19
5 -1 4 2 0
1 2
69
Output
391 0
0 6 1 3 5
0
Note
In the first test case the array changes as follows:
* Initially, the array is [-199, 192]. d = 192.
* After the operation, the array becomes [d-(-199), d-192] = [391, 0]. | instruction | 0 | 58,201 | 2 | 116,402 |
Tags: implementation, math
Correct Solution:
```
for _ in range(int(input())):
n,k = map(int,input().split())
a = list(map(int,input().split()))
d = max(a)
l = list(map(lambda x: d-x, a))
d1 = max(l)
l1 = list(map(lambda x: d1-x, l))
if (k-1)%2==0: print(*l)
else: print(*l1)
``` | output | 1 | 58,201 | 2 | 116,403 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Being stuck at home, Ray became extremely bored. To pass time, he asks Lord Omkar to use his time bending power: Infinity Clock! However, Lord Omkar will only listen to mortals who can solve the following problem:
You are given an array a of n integers. You are also given an integer k. Lord Omkar wants you to do k operations with this array.
Define one operation as the following:
1. Set d to be the maximum value of your array.
2. For every i from 1 to n, replace a_{i} with d-a_{i}.
The goal is to predict the contents in the array after k operations. Please help Ray determine what the final sequence will look like!
Input
Each test contains multiple test cases. The first line contains the number of cases t (1 ≤ t ≤ 100). Description of the test cases follows.
The first line of each test case contains two integers n and k (1 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ k ≤ 10^{18}) – the length of your array and the number of operations to perform.
The second line of each test case contains n integers a_{1},a_{2},...,a_{n} (-10^9 ≤ a_{i} ≤ 10^9) – the initial contents of your array.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each case, print the final version of array a after k operations described above.
Example
Input
3
2 1
-199 192
5 19
5 -1 4 2 0
1 2
69
Output
391 0
0 6 1 3 5
0
Note
In the first test case the array changes as follows:
* Initially, the array is [-199, 192]. d = 192.
* After the operation, the array becomes [d-(-199), d-192] = [391, 0]. | instruction | 0 | 58,202 | 2 | 116,404 |
Tags: implementation, math
Correct Solution:
```
for _ in range(int(input())):
n,k=map(int,input().split())
a=list(map(int,input().split()))
t=max(a)
for i in range(len(a)):
a[i] = t - a[i]
t=max(a)
if k%2==0:
for i in range(len(a)):
a[i]=t-a[i]
print(*a)
``` | output | 1 | 58,202 | 2 | 116,405 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Being stuck at home, Ray became extremely bored. To pass time, he asks Lord Omkar to use his time bending power: Infinity Clock! However, Lord Omkar will only listen to mortals who can solve the following problem:
You are given an array a of n integers. You are also given an integer k. Lord Omkar wants you to do k operations with this array.
Define one operation as the following:
1. Set d to be the maximum value of your array.
2. For every i from 1 to n, replace a_{i} with d-a_{i}.
The goal is to predict the contents in the array after k operations. Please help Ray determine what the final sequence will look like!
Input
Each test contains multiple test cases. The first line contains the number of cases t (1 ≤ t ≤ 100). Description of the test cases follows.
The first line of each test case contains two integers n and k (1 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ k ≤ 10^{18}) – the length of your array and the number of operations to perform.
The second line of each test case contains n integers a_{1},a_{2},...,a_{n} (-10^9 ≤ a_{i} ≤ 10^9) – the initial contents of your array.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each case, print the final version of array a after k operations described above.
Example
Input
3
2 1
-199 192
5 19
5 -1 4 2 0
1 2
69
Output
391 0
0 6 1 3 5
0
Note
In the first test case the array changes as follows:
* Initially, the array is [-199, 192]. d = 192.
* After the operation, the array becomes [d-(-199), d-192] = [391, 0]. | instruction | 0 | 58,203 | 2 | 116,406 |
Tags: implementation, math
Correct Solution:
```
for _ in range(int(input())):
n, k = map(int, input().split(' '))
A = list(map(int, str(input().strip()).split(' ')))
if(n == 1):
print(0)
else:
z = k % 2
if(z == 1):
_mx = max(A)
print(*[_mx - x for x in A])
else:
_mx = max(A)
A = [_mx - x for x in A]
_mx = max(A)
print(*[_mx - x for x in A])
``` | output | 1 | 58,203 | 2 | 116,407 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Being stuck at home, Ray became extremely bored. To pass time, he asks Lord Omkar to use his time bending power: Infinity Clock! However, Lord Omkar will only listen to mortals who can solve the following problem:
You are given an array a of n integers. You are also given an integer k. Lord Omkar wants you to do k operations with this array.
Define one operation as the following:
1. Set d to be the maximum value of your array.
2. For every i from 1 to n, replace a_{i} with d-a_{i}.
The goal is to predict the contents in the array after k operations. Please help Ray determine what the final sequence will look like!
Input
Each test contains multiple test cases. The first line contains the number of cases t (1 ≤ t ≤ 100). Description of the test cases follows.
The first line of each test case contains two integers n and k (1 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ k ≤ 10^{18}) – the length of your array and the number of operations to perform.
The second line of each test case contains n integers a_{1},a_{2},...,a_{n} (-10^9 ≤ a_{i} ≤ 10^9) – the initial contents of your array.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each case, print the final version of array a after k operations described above.
Example
Input
3
2 1
-199 192
5 19
5 -1 4 2 0
1 2
69
Output
391 0
0 6 1 3 5
0
Note
In the first test case the array changes as follows:
* Initially, the array is [-199, 192]. d = 192.
* After the operation, the array becomes [d-(-199), d-192] = [391, 0]. | instruction | 0 | 58,204 | 2 | 116,408 |
Tags: implementation, math
Correct Solution:
```
import sys
input = sys.stdin.readline
def main(n, k, lst):
lst1 = []
maxx, minn = max(lst), min(lst)
if k % 2:
for i in lst:
lst1.append(maxx - i)
return lst1
else:
for i in lst:
lst1.append(i - minn)
return lst1
for _ in range(int(input())):
n, k = list(map(int, input().split()))
lst = list(map(int, input().split()))
print(" ".join(list(map(str, main(n, k, lst)))))
``` | output | 1 | 58,204 | 2 | 116,409 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Being stuck at home, Ray became extremely bored. To pass time, he asks Lord Omkar to use his time bending power: Infinity Clock! However, Lord Omkar will only listen to mortals who can solve the following problem:
You are given an array a of n integers. You are also given an integer k. Lord Omkar wants you to do k operations with this array.
Define one operation as the following:
1. Set d to be the maximum value of your array.
2. For every i from 1 to n, replace a_{i} with d-a_{i}.
The goal is to predict the contents in the array after k operations. Please help Ray determine what the final sequence will look like!
Input
Each test contains multiple test cases. The first line contains the number of cases t (1 ≤ t ≤ 100). Description of the test cases follows.
The first line of each test case contains two integers n and k (1 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ k ≤ 10^{18}) – the length of your array and the number of operations to perform.
The second line of each test case contains n integers a_{1},a_{2},...,a_{n} (-10^9 ≤ a_{i} ≤ 10^9) – the initial contents of your array.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each case, print the final version of array a after k operations described above.
Example
Input
3
2 1
-199 192
5 19
5 -1 4 2 0
1 2
69
Output
391 0
0 6 1 3 5
0
Note
In the first test case the array changes as follows:
* Initially, the array is [-199, 192]. d = 192.
* After the operation, the array becomes [d-(-199), d-192] = [391, 0]. | instruction | 0 | 58,205 | 2 | 116,410 |
Tags: implementation, math
Correct Solution:
```
n = int(input())
for _ in range(n):
n, k = map(int, input().split(' '))
array = list(map(int, input().split(' ')))
for i in range((k+1)%2 + 1):
highest = max(array)
array = [highest-a for a in array]
print(*array)
``` | output | 1 | 58,205 | 2 | 116,411 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Being stuck at home, Ray became extremely bored. To pass time, he asks Lord Omkar to use his time bending power: Infinity Clock! However, Lord Omkar will only listen to mortals who can solve the following problem:
You are given an array a of n integers. You are also given an integer k. Lord Omkar wants you to do k operations with this array.
Define one operation as the following:
1. Set d to be the maximum value of your array.
2. For every i from 1 to n, replace a_{i} with d-a_{i}.
The goal is to predict the contents in the array after k operations. Please help Ray determine what the final sequence will look like!
Input
Each test contains multiple test cases. The first line contains the number of cases t (1 ≤ t ≤ 100). Description of the test cases follows.
The first line of each test case contains two integers n and k (1 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ k ≤ 10^{18}) – the length of your array and the number of operations to perform.
The second line of each test case contains n integers a_{1},a_{2},...,a_{n} (-10^9 ≤ a_{i} ≤ 10^9) – the initial contents of your array.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each case, print the final version of array a after k operations described above.
Example
Input
3
2 1
-199 192
5 19
5 -1 4 2 0
1 2
69
Output
391 0
0 6 1 3 5
0
Note
In the first test case the array changes as follows:
* Initially, the array is [-199, 192]. d = 192.
* After the operation, the array becomes [d-(-199), d-192] = [391, 0]. | instruction | 0 | 58,206 | 2 | 116,412 |
Tags: implementation, math
Correct Solution:
```
t=int(input())
for _ in range(t):
n,k=map(int,input().split(" "))
a=list(map(int,input().split()))
if k%2==0:
for i in range(2):
m=max(a)
for i in range(n):
a[i]=m-a[i]
print(*a)
else:
m=max(a)
for i in range(n):
a[i]=m-a[i]
print(*a)
``` | output | 1 | 58,206 | 2 | 116,413 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Being stuck at home, Ray became extremely bored. To pass time, he asks Lord Omkar to use his time bending power: Infinity Clock! However, Lord Omkar will only listen to mortals who can solve the following problem:
You are given an array a of n integers. You are also given an integer k. Lord Omkar wants you to do k operations with this array.
Define one operation as the following:
1. Set d to be the maximum value of your array.
2. For every i from 1 to n, replace a_{i} with d-a_{i}.
The goal is to predict the contents in the array after k operations. Please help Ray determine what the final sequence will look like!
Input
Each test contains multiple test cases. The first line contains the number of cases t (1 ≤ t ≤ 100). Description of the test cases follows.
The first line of each test case contains two integers n and k (1 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ k ≤ 10^{18}) – the length of your array and the number of operations to perform.
The second line of each test case contains n integers a_{1},a_{2},...,a_{n} (-10^9 ≤ a_{i} ≤ 10^9) – the initial contents of your array.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each case, print the final version of array a after k operations described above.
Example
Input
3
2 1
-199 192
5 19
5 -1 4 2 0
1 2
69
Output
391 0
0 6 1 3 5
0
Note
In the first test case the array changes as follows:
* Initially, the array is [-199, 192]. d = 192.
* After the operation, the array becomes [d-(-199), d-192] = [391, 0]. | instruction | 0 | 58,207 | 2 | 116,414 |
Tags: implementation, math
Correct Solution:
```
t=int(input())
while(t>0):
t=t-1
[n,k]=input().split()
n=int(n)
k=int(k)
a=input().split()
for i in range(0,n):
a[i]=int(a[i])
ma=max(a)
mi=min(a)
if(k%2==0):
for i in a:
print(i-mi,end=" ")
print()
else:
for i in a:
print(ma-i,end=" ")
print()
``` | output | 1 | 58,207 | 2 | 116,415 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Being stuck at home, Ray became extremely bored. To pass time, he asks Lord Omkar to use his time bending power: Infinity Clock! However, Lord Omkar will only listen to mortals who can solve the following problem:
You are given an array a of n integers. You are also given an integer k. Lord Omkar wants you to do k operations with this array.
Define one operation as the following:
1. Set d to be the maximum value of your array.
2. For every i from 1 to n, replace a_{i} with d-a_{i}.
The goal is to predict the contents in the array after k operations. Please help Ray determine what the final sequence will look like!
Input
Each test contains multiple test cases. The first line contains the number of cases t (1 ≤ t ≤ 100). Description of the test cases follows.
The first line of each test case contains two integers n and k (1 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ k ≤ 10^{18}) – the length of your array and the number of operations to perform.
The second line of each test case contains n integers a_{1},a_{2},...,a_{n} (-10^9 ≤ a_{i} ≤ 10^9) – the initial contents of your array.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each case, print the final version of array a after k operations described above.
Example
Input
3
2 1
-199 192
5 19
5 -1 4 2 0
1 2
69
Output
391 0
0 6 1 3 5
0
Note
In the first test case the array changes as follows:
* Initially, the array is [-199, 192]. d = 192.
* After the operation, the array becomes [d-(-199), d-192] = [391, 0]. | instruction | 0 | 58,208 | 2 | 116,416 |
Tags: implementation, math
Correct Solution:
```
t=int(input())
for i in range(0,t):
m,n=map(int,input().split())
arr=list(map(int,input().strip().split()))[:m]
x=max(arr)
arr1=[]
arr2=[]
for j in range(0,m):
y=x-arr[j]
arr1.append(y)
xx=max(arr1)
for j in range(0,m):
yy=xx-arr1[j]
arr2.append(yy)
if(n==0):
print(*arr,sep=" ")
elif(n%2==0):
print(*arr2,sep=" ")
else:
print(*arr1,sep=" ")
``` | output | 1 | 58,208 | 2 | 116,417 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Being stuck at home, Ray became extremely bored. To pass time, he asks Lord Omkar to use his time bending power: Infinity Clock! However, Lord Omkar will only listen to mortals who can solve the following problem:
You are given an array a of n integers. You are also given an integer k. Lord Omkar wants you to do k operations with this array.
Define one operation as the following:
1. Set d to be the maximum value of your array.
2. For every i from 1 to n, replace a_{i} with d-a_{i}.
The goal is to predict the contents in the array after k operations. Please help Ray determine what the final sequence will look like!
Input
Each test contains multiple test cases. The first line contains the number of cases t (1 ≤ t ≤ 100). Description of the test cases follows.
The first line of each test case contains two integers n and k (1 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ k ≤ 10^{18}) – the length of your array and the number of operations to perform.
The second line of each test case contains n integers a_{1},a_{2},...,a_{n} (-10^9 ≤ a_{i} ≤ 10^9) – the initial contents of your array.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each case, print the final version of array a after k operations described above.
Example
Input
3
2 1
-199 192
5 19
5 -1 4 2 0
1 2
69
Output
391 0
0 6 1 3 5
0
Note
In the first test case the array changes as follows:
* Initially, the array is [-199, 192]. d = 192.
* After the operation, the array becomes [d-(-199), d-192] = [391, 0].
Submitted Solution:
```
# -*- coding: utf-8 -*-
"""
Created on Sun Aug 16 21:18:31 2020
@author: ASUS
"""
t=int(input())
while(t>0):
n,k=map(int,input().split())
arr=list(map(int,input().split()))
arr1=[]
m=max(arr)
for i in arr:
arr1.append(m-i)
arr2=[]
m=max(arr1)
for i in arr1:
arr2.append(m-i)
if(k%2==1):
for i in arr1:
print(i,end=" ")
else:
for i in arr2:
print(i,end=" ")
t-=1
print("")
``` | instruction | 0 | 58,209 | 2 | 116,418 |
Yes | output | 1 | 58,209 | 2 | 116,419 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Being stuck at home, Ray became extremely bored. To pass time, he asks Lord Omkar to use his time bending power: Infinity Clock! However, Lord Omkar will only listen to mortals who can solve the following problem:
You are given an array a of n integers. You are also given an integer k. Lord Omkar wants you to do k operations with this array.
Define one operation as the following:
1. Set d to be the maximum value of your array.
2. For every i from 1 to n, replace a_{i} with d-a_{i}.
The goal is to predict the contents in the array after k operations. Please help Ray determine what the final sequence will look like!
Input
Each test contains multiple test cases. The first line contains the number of cases t (1 ≤ t ≤ 100). Description of the test cases follows.
The first line of each test case contains two integers n and k (1 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ k ≤ 10^{18}) – the length of your array and the number of operations to perform.
The second line of each test case contains n integers a_{1},a_{2},...,a_{n} (-10^9 ≤ a_{i} ≤ 10^9) – the initial contents of your array.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each case, print the final version of array a after k operations described above.
Example
Input
3
2 1
-199 192
5 19
5 -1 4 2 0
1 2
69
Output
391 0
0 6 1 3 5
0
Note
In the first test case the array changes as follows:
* Initially, the array is [-199, 192]. d = 192.
* After the operation, the array becomes [d-(-199), d-192] = [391, 0].
Submitted Solution:
```
T = int(input())
for _ in range(T):
n,k = map(int,input().split())
a = list(map(int, input().split()))
maxx = max(a)
minn = min(a)
tr = maxx-minn
if k%2==1:
for i in range(n):
a[i] = maxx-a[i]
else:
for i in range(n):
a[i] = tr-maxx+a[i]
print(*a)
``` | instruction | 0 | 58,210 | 2 | 116,420 |
Yes | output | 1 | 58,210 | 2 | 116,421 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Being stuck at home, Ray became extremely bored. To pass time, he asks Lord Omkar to use his time bending power: Infinity Clock! However, Lord Omkar will only listen to mortals who can solve the following problem:
You are given an array a of n integers. You are also given an integer k. Lord Omkar wants you to do k operations with this array.
Define one operation as the following:
1. Set d to be the maximum value of your array.
2. For every i from 1 to n, replace a_{i} with d-a_{i}.
The goal is to predict the contents in the array after k operations. Please help Ray determine what the final sequence will look like!
Input
Each test contains multiple test cases. The first line contains the number of cases t (1 ≤ t ≤ 100). Description of the test cases follows.
The first line of each test case contains two integers n and k (1 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ k ≤ 10^{18}) – the length of your array and the number of operations to perform.
The second line of each test case contains n integers a_{1},a_{2},...,a_{n} (-10^9 ≤ a_{i} ≤ 10^9) – the initial contents of your array.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each case, print the final version of array a after k operations described above.
Example
Input
3
2 1
-199 192
5 19
5 -1 4 2 0
1 2
69
Output
391 0
0 6 1 3 5
0
Note
In the first test case the array changes as follows:
* Initially, the array is [-199, 192]. d = 192.
* After the operation, the array becomes [d-(-199), d-192] = [391, 0].
Submitted Solution:
```
from math import *
from copy import *
from string import * # alpha = ascii_lowercase
from random import *
from sys import stdin,stdout
from sys import maxsize
from operator import * # d = sorted(d.items(), key=itemgetter(1))
from itertools import *
from collections import Counter # d = dict(Counter(l))
import math
import math
import time
from queue import Queue
# PradeepGhosh_2017076
def seive(n):
l=[True]
l=l*(n+1)
for i in range(2,int(sqrt(n))+1):
if(l[i]==True):
val=i*i
while(val<len(l)):
l[val]=False
val+=i
prime=[]
for i in range(2,len(l)):
if(l[i]==True):
prime.append(i)
return prime
def dp(l,i,n,val,ans):
if(i>=n or val<0):
return 1000000
elif(val==0):
return 0
else:
if(ans[i]==1000000):
ans[i]=min(min(1+dp(l,i+1,n,val-l[i],ans),1+dp(l,i,n,val-l[i],ans)),dp(l,i+1,n,val,ans))
return ans[i]
from queue import Queue
def factors(n):
l=[]
for i in range(1,int(sqrt(n))+1):
if(n%i==0):
if(n//i==i):
l.append(i)
else:
l.append(i)
l.append(n//i)
return l
def check1(s,v,x):
while(True):
if(v not in s):
return v
else:
v-=1
def check2(s,v,x):
while(True):
if(v not in s):
return v
else:
v+=1
def up(n):
j=n-1
while(j>0):
if(n%j==0):
break
j-=1
return j
def fac(n):
c=1
i=1
while(i<=n):
c*=i
i+=1
return c
def check_happy(n):
ss=set()
print(n)
while(n!=1):
val=n
s=0
print(val)
while(val!=0):
s+=(val%10)**2
val=val//10
print(val)
print("hi")
if(val in ss):
return False
else:
n=val
ss.add(n)
return True
def update(a,b):
c=1
val=a
while(a<b):
print(c,a)
c+=c
a+=a
print(1)
while(a>b):
print()
a-=val
c-=1
return c
import random as rand
def gcd(a,b):
if a == 0:
return b
return gcd(b % a, a)
# nakdna
from itertools import permutations
def insertion_sort(arr):
for i in range(len(arr)):
j=i
while(j>0):
if(arr[j]<arr[j-1]):
temp=arr[j]
arr[j]=arr[j-1]
arr[j-1]=temp
j-=1
return arr
def quick_sort(arr,low,high):
i=low
j=high
while(i<j):
if(arr[i]>arr[low] and arr[j]<arr[low]):
temp=arr[i]
arr[i]=arr[j]
arr[j]=arr[i]
i+=1
j-=1
elif(arr[i]<=arr[low]):
i+=1
elif(arr[j]>=arr[low]):
j-=1
print(i,j)
toto=arr[j]
arr[j]=arr[low]
arr[low]=toto
return j
def dodo(arr,low,high):
if(low<high):
val=quick_sort(arr,low,high)
dodo(arr,low,val-1)
dodo(arr,val+1,high)
def dp(arr,c,n,k,z,ans):
if(k==0):
return ans
else:
if(c==0):
return dp(arr,c+1,n,k-1,z,ans+arr[c+1])
elif(c==n-1):
if(z==0):
return 0
else:
return dp(arr,c-1,n,k-1,z-1,ans+arr[c-1])
else:
if(z==0):
return dp(arr,c+1,n,k-1,z,ans+arr[c+1])
else:
return max(dp(arr,c+1,n,k-1,z,ans+arr[c+1]),dp(arr,c-1,n,k-1,z-1,ans+arr[c-1]))
def check(arr,val):
a=-1
for i in range(len(arr)):
if(arr[i][len(arr[i])-1]==val):
a=i
break
return a
def reverse(s,i,ans):
if(i>=len(s)):
return ans
else:
return reverse(s,i+1,s[i]+ans)
def update(arr,i,j,n,m):
if(i>=0 and i<n and j>=0 and j<m):
if(arr[i][j]==1):
arr[i][j]==2
return [i,j]
return [-1,-1]
if __name__ == '__main__':
t=int(stdin.readline())
for i in range(t):
n,k=map(int,stdin.readline().split(" "))
l=list(map(int,stdin.readline().split(" ")))
maxa=max(l)
mini=min(l)
if(maxa==mini):
ans=[0]*n
print(*ans)
else:
for j in range(n):
l[j]=maxa-l[j]
k-=1
if(k%2==0):
print(*l)
else:
maxa=max(l)
for j in range(n):
l[j]=maxa-l[j]
print(*l)
``` | instruction | 0 | 58,211 | 2 | 116,422 |
Yes | output | 1 | 58,211 | 2 | 116,423 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Being stuck at home, Ray became extremely bored. To pass time, he asks Lord Omkar to use his time bending power: Infinity Clock! However, Lord Omkar will only listen to mortals who can solve the following problem:
You are given an array a of n integers. You are also given an integer k. Lord Omkar wants you to do k operations with this array.
Define one operation as the following:
1. Set d to be the maximum value of your array.
2. For every i from 1 to n, replace a_{i} with d-a_{i}.
The goal is to predict the contents in the array after k operations. Please help Ray determine what the final sequence will look like!
Input
Each test contains multiple test cases. The first line contains the number of cases t (1 ≤ t ≤ 100). Description of the test cases follows.
The first line of each test case contains two integers n and k (1 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ k ≤ 10^{18}) – the length of your array and the number of operations to perform.
The second line of each test case contains n integers a_{1},a_{2},...,a_{n} (-10^9 ≤ a_{i} ≤ 10^9) – the initial contents of your array.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each case, print the final version of array a after k operations described above.
Example
Input
3
2 1
-199 192
5 19
5 -1 4 2 0
1 2
69
Output
391 0
0 6 1 3 5
0
Note
In the first test case the array changes as follows:
* Initially, the array is [-199, 192]. d = 192.
* After the operation, the array becomes [d-(-199), d-192] = [391, 0].
Submitted Solution:
```
import sys,math
from collections import deque,defaultdict
import operator as op
from functools import reduce
sys.setrecursionlimit(10**6)
I=sys.stdin.readline
#s="abcdefghijklmnopqrstuvwxyz"
#
def ii():
return int(I().strip())
def li():
return list(map(int,I().strip().split()))
def mi():
return map(int,I().strip().split())
def ncr(n, r):
r = min(r, n-r)
numer = reduce(op.mul, range(n, n-r, -1), 1)
denom = reduce(op.mul, range(1, r+1), 1)
return numer // denom
def gcd(x, y):
while y:
x, y = y, x % y
return x
def main():
for _ in range(ii()):
n,k=mi()
arr=li()
d=max(arr)
for j in range(n):
arr[j]=d-arr[j]
if k%2:
print(*arr)
else:
d=max(arr)
for j in range(n):
arr[j]=d-arr[j]
print(*arr)
if __name__ == '__main__':
main()
``` | instruction | 0 | 58,212 | 2 | 116,424 |
Yes | output | 1 | 58,212 | 2 | 116,425 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Being stuck at home, Ray became extremely bored. To pass time, he asks Lord Omkar to use his time bending power: Infinity Clock! However, Lord Omkar will only listen to mortals who can solve the following problem:
You are given an array a of n integers. You are also given an integer k. Lord Omkar wants you to do k operations with this array.
Define one operation as the following:
1. Set d to be the maximum value of your array.
2. For every i from 1 to n, replace a_{i} with d-a_{i}.
The goal is to predict the contents in the array after k operations. Please help Ray determine what the final sequence will look like!
Input
Each test contains multiple test cases. The first line contains the number of cases t (1 ≤ t ≤ 100). Description of the test cases follows.
The first line of each test case contains two integers n and k (1 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ k ≤ 10^{18}) – the length of your array and the number of operations to perform.
The second line of each test case contains n integers a_{1},a_{2},...,a_{n} (-10^9 ≤ a_{i} ≤ 10^9) – the initial contents of your array.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each case, print the final version of array a after k operations described above.
Example
Input
3
2 1
-199 192
5 19
5 -1 4 2 0
1 2
69
Output
391 0
0 6 1 3 5
0
Note
In the first test case the array changes as follows:
* Initially, the array is [-199, 192]. d = 192.
* After the operation, the array becomes [d-(-199), d-192] = [391, 0].
Submitted Solution:
```
t=int(input())
for q in range(t):
n,k=map(int, input().split())
arr=list(map(int,input().split()))
d=max(arr)
for i in range(n):
arr[i]=d-arr[i]
for i in arr:
print(i,end=' ')
print()
``` | instruction | 0 | 58,213 | 2 | 116,426 |
No | output | 1 | 58,213 | 2 | 116,427 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Being stuck at home, Ray became extremely bored. To pass time, he asks Lord Omkar to use his time bending power: Infinity Clock! However, Lord Omkar will only listen to mortals who can solve the following problem:
You are given an array a of n integers. You are also given an integer k. Lord Omkar wants you to do k operations with this array.
Define one operation as the following:
1. Set d to be the maximum value of your array.
2. For every i from 1 to n, replace a_{i} with d-a_{i}.
The goal is to predict the contents in the array after k operations. Please help Ray determine what the final sequence will look like!
Input
Each test contains multiple test cases. The first line contains the number of cases t (1 ≤ t ≤ 100). Description of the test cases follows.
The first line of each test case contains two integers n and k (1 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ k ≤ 10^{18}) – the length of your array and the number of operations to perform.
The second line of each test case contains n integers a_{1},a_{2},...,a_{n} (-10^9 ≤ a_{i} ≤ 10^9) – the initial contents of your array.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each case, print the final version of array a after k operations described above.
Example
Input
3
2 1
-199 192
5 19
5 -1 4 2 0
1 2
69
Output
391 0
0 6 1 3 5
0
Note
In the first test case the array changes as follows:
* Initially, the array is [-199, 192]. d = 192.
* After the operation, the array becomes [d-(-199), d-192] = [391, 0].
Submitted Solution:
```
for _ in range(int(input())):
n,k=map(int,input().split())
l=[int(i) for i in input().split()]
if n==1:
print(0)
continue
while k!=0:
m=max(l)
m2=min(l)
if m2>=0 and m2!=m:
break
else:
l=[m-i for i in l]
k=k-1
for j in range(0,n-1,1):
print(l[j],end=' ')
print(l[n-1])
``` | instruction | 0 | 58,214 | 2 | 116,428 |
No | output | 1 | 58,214 | 2 | 116,429 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Being stuck at home, Ray became extremely bored. To pass time, he asks Lord Omkar to use his time bending power: Infinity Clock! However, Lord Omkar will only listen to mortals who can solve the following problem:
You are given an array a of n integers. You are also given an integer k. Lord Omkar wants you to do k operations with this array.
Define one operation as the following:
1. Set d to be the maximum value of your array.
2. For every i from 1 to n, replace a_{i} with d-a_{i}.
The goal is to predict the contents in the array after k operations. Please help Ray determine what the final sequence will look like!
Input
Each test contains multiple test cases. The first line contains the number of cases t (1 ≤ t ≤ 100). Description of the test cases follows.
The first line of each test case contains two integers n and k (1 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ k ≤ 10^{18}) – the length of your array and the number of operations to perform.
The second line of each test case contains n integers a_{1},a_{2},...,a_{n} (-10^9 ≤ a_{i} ≤ 10^9) – the initial contents of your array.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each case, print the final version of array a after k operations described above.
Example
Input
3
2 1
-199 192
5 19
5 -1 4 2 0
1 2
69
Output
391 0
0 6 1 3 5
0
Note
In the first test case the array changes as follows:
* Initially, the array is [-199, 192]. d = 192.
* After the operation, the array becomes [d-(-199), d-192] = [391, 0].
Submitted Solution:
```
for _ in range(int(input())):
x,y=map(int,input().split())
a=list(map(int,input().split()))
k=max(a)
for i in a:
print(k-i,end=" ")
print()
``` | instruction | 0 | 58,215 | 2 | 116,430 |
No | output | 1 | 58,215 | 2 | 116,431 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Being stuck at home, Ray became extremely bored. To pass time, he asks Lord Omkar to use his time bending power: Infinity Clock! However, Lord Omkar will only listen to mortals who can solve the following problem:
You are given an array a of n integers. You are also given an integer k. Lord Omkar wants you to do k operations with this array.
Define one operation as the following:
1. Set d to be the maximum value of your array.
2. For every i from 1 to n, replace a_{i} with d-a_{i}.
The goal is to predict the contents in the array after k operations. Please help Ray determine what the final sequence will look like!
Input
Each test contains multiple test cases. The first line contains the number of cases t (1 ≤ t ≤ 100). Description of the test cases follows.
The first line of each test case contains two integers n and k (1 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ k ≤ 10^{18}) – the length of your array and the number of operations to perform.
The second line of each test case contains n integers a_{1},a_{2},...,a_{n} (-10^9 ≤ a_{i} ≤ 10^9) – the initial contents of your array.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each case, print the final version of array a after k operations described above.
Example
Input
3
2 1
-199 192
5 19
5 -1 4 2 0
1 2
69
Output
391 0
0 6 1 3 5
0
Note
In the first test case the array changes as follows:
* Initially, the array is [-199, 192]. d = 192.
* After the operation, the array becomes [d-(-199), d-192] = [391, 0].
Submitted Solution:
```
for t in range(int(input())):
n,k=map(int,input().split())
a=list(map(int,input().split()))
k1=k
for i in range(k1):
MAX=max(a)
for j in range(len(a)):
a[j]=MAX-a[j]
print(*a)
``` | instruction | 0 | 58,216 | 2 | 116,432 |
No | output | 1 | 58,216 | 2 | 116,433 |
Provide a correct Python 3 solution for this coding contest problem.
You have N bamboos. The lengths (in centimeters) of these are l_1, l_2, ..., l_N, respectively.
Your objective is to use some of these bamboos (possibly all) to obtain three bamboos of length A, B, C. For that, you can use the following three kinds of magics any number:
* Extension Magic: Consumes 1 MP (magic point). Choose one bamboo and increase its length by 1.
* Shortening Magic: Consumes 1 MP. Choose one bamboo of length at least 2 and decrease its length by 1.
* Composition Magic: Consumes 10 MP. Choose two bamboos and combine them into one bamboo. The length of this new bamboo is equal to the sum of the lengths of the two bamboos combined. (Afterwards, further magics can be used on this bamboo.)
At least how much MP is needed to achieve the objective?
Constraints
* 3 \leq N \leq 8
* 1 \leq C < B < A \leq 1000
* 1 \leq l_i \leq 1000
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N A B C
l_1
l_2
:
l_N
Output
Print the minimum amount of MP needed to achieve the objective.
Examples
Input
5 100 90 80
98
40
30
21
80
Output
23
Input
8 100 90 80
100
100
90
90
90
80
80
80
Output
0
Input
8 1000 800 100
300
333
400
444
500
555
600
666
Output
243 | instruction | 0 | 58,714 | 2 | 117,428 |
"Correct Solution:
```
N, A, B, C = map(int, input().split())
l = [int(input()) for i in range(N)]
INF = 10 ** 9
def dfs(cur, a, b, c):
if cur == N:
if min(a,b,c) > 0:
return abs(a-A) + abs(B-b) + abs(C-c) - 30
else:
return INF
ret0 = dfs(cur+1, a, b, c)
ret1 = dfs(cur+1, a+l[cur], b, c) + 10
ret2 = dfs(cur+1, a, b+l[cur], c) + 10
ret3 = dfs(cur+1, a, b, c+l[cur]) + 10
return min(ret0,ret1,ret2,ret3)
print (dfs(0,0,0,0))
``` | output | 1 | 58,714 | 2 | 117,429 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have N bamboos. The lengths (in centimeters) of these are l_1, l_2, ..., l_N, respectively.
Your objective is to use some of these bamboos (possibly all) to obtain three bamboos of length A, B, C. For that, you can use the following three kinds of magics any number:
* Extension Magic: Consumes 1 MP (magic point). Choose one bamboo and increase its length by 1.
* Shortening Magic: Consumes 1 MP. Choose one bamboo of length at least 2 and decrease its length by 1.
* Composition Magic: Consumes 10 MP. Choose two bamboos and combine them into one bamboo. The length of this new bamboo is equal to the sum of the lengths of the two bamboos combined. (Afterwards, further magics can be used on this bamboo.)
At least how much MP is needed to achieve the objective?
Constraints
* 3 \leq N \leq 8
* 1 \leq C < B < A \leq 1000
* 1 \leq l_i \leq 1000
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N A B C
l_1
l_2
:
l_N
Output
Print the minimum amount of MP needed to achieve the objective.
Examples
Input
5 100 90 80
98
40
30
21
80
Output
23
Input
8 100 90 80
100
100
90
90
90
80
80
80
Output
0
Input
8 1000 800 100
300
333
400
444
500
555
600
666
Output
243
Submitted Solution:
```
N, A, B, C = map(int, input().split())
L = [int(input()) for _ in range(N)]
def dfs(n, a, b, c): # n本目を使用するかしないか
if n == N: # 全ての竹を選び終わったら、延長魔法と短縮魔法を使ってA,B,Cの長さにする
return abs(A-a)+abs(B-b)+abs(C-c)-30 # 最低でも1本のみ使用するが、その場合は合成しないため-30
ret0 = dfs(n + 1, a, b, c) # 使わない
ret1 = dfs(n + 1, a + L[n], b, c) + 10 # Aに使う
ret2 = dfs(n + 1, a, b + L[n], c) + 10 # Bに使う
ret3 = dfs(n + 1, a, b, c + L[n]) + 10 # Cに使う
return min(ret0, ret1, ret2, ret3)
print(dfs(0,0,0,0))
``` | instruction | 0 | 58,726 | 2 | 117,452 |
No | output | 1 | 58,726 | 2 | 117,453 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have N bamboos. The lengths (in centimeters) of these are l_1, l_2, ..., l_N, respectively.
Your objective is to use some of these bamboos (possibly all) to obtain three bamboos of length A, B, C. For that, you can use the following three kinds of magics any number:
* Extension Magic: Consumes 1 MP (magic point). Choose one bamboo and increase its length by 1.
* Shortening Magic: Consumes 1 MP. Choose one bamboo of length at least 2 and decrease its length by 1.
* Composition Magic: Consumes 10 MP. Choose two bamboos and combine them into one bamboo. The length of this new bamboo is equal to the sum of the lengths of the two bamboos combined. (Afterwards, further magics can be used on this bamboo.)
At least how much MP is needed to achieve the objective?
Constraints
* 3 \leq N \leq 8
* 1 \leq C < B < A \leq 1000
* 1 \leq l_i \leq 1000
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N A B C
l_1
l_2
:
l_N
Output
Print the minimum amount of MP needed to achieve the objective.
Examples
Input
5 100 90 80
98
40
30
21
80
Output
23
Input
8 100 90 80
100
100
90
90
90
80
80
80
Output
0
Input
8 1000 800 100
300
333
400
444
500
555
600
666
Output
243
Submitted Solution:
```
def Base_10_to_n(X, n):
if (int(X/n)):
return Base_10_to_n(int(X/n), n)+str(X%n)
return str(X%n)
n,a,b,c=map(int,input().split())
L=[]
for _ in range(n):
L.append(int(input()))
at,bt,ct=[],[],[]
ans_list=[]
ans=999999999
for i in range(4**len(L)-1):
i_4_list=list(Base_10_to_n(i, 4).zfill(len(L)))
at,bt,ct=[],[],[]
for num,i_4 in enumerate(i_4_list):
if i_4=='0':
at.append(L[num])
elif i_4=='1':
bt.append(L[num])
elif i_4=='2':
ct.append(L[num])
else:
continue
if at!=[] and ct!=[] and ct!=[]:
al=0
al+=(len(at)+len(bt)+len(ct)-3)*10
al+=(abs(sum(at)-a)+abs(sum(bt)-b)+abs(sum(ct)-c))
if al < ans:
ans=al
print(ans)
``` | instruction | 0 | 58,729 | 2 | 117,458 |
No | output | 1 | 58,729 | 2 | 117,459 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Fire Lord attacked the Frost Kingdom. He has already got to the Ice Fortress, where the Snow Queen dwells. He arranged his army on a segment n in length not far from the city walls. And only the frost magician Solomon can save the Frost Kingdom.
<image>
The n-long segment is located at a distance equal exactly to 1 from the castle walls. It can be imaginarily divided into unit segments. On some of the unit segments fire demons are located — no more than one demon per position. Each demon is characterised by his strength - by some positive integer. We can regard the fire demons being idle.
Initially Solomon is positioned on the fortress wall. He can perform the following actions several times in a row:
* "L" — Solomon shifts one unit to the left. This movement cannot be performed on the castle wall.
* "R" — Solomon shifts one unit to the left. This movement cannot be performed if there's no ice block to the right.
* "A" — If there's nothing to the right of Solomon, then Solomon creates an ice block that immediately freezes to the block that Solomon is currently standing on. If there already is an ice block, then Solomon destroys it. At that the ice blocks to the right of the destroyed one can remain but they are left unsupported. Those ice blocks fall down.
Solomon spends exactly a second on each of these actions.
As the result of Solomon's actions, ice blocks' segments fall down. When an ice block falls on a fire demon, the block evaporates and the demon's strength is reduced by 1. When the demons' strength is equal to 0, the fire demon vanishes. The picture below shows how it happens. The ice block that falls on the position with no demon, breaks into lots of tiny pieces and vanishes without hurting anybody.
<image>
Help Solomon destroy all the Fire Lord's army in minimum time.
Input
The first line contains an integer n (1 ≤ n ≤ 1000). The next line contains n numbers, the i-th of them represents the strength of the fire demon standing of the i-th position, an integer from 1 to 100. If there's no demon on the i-th position, then the i-th number equals to 0. It is guaranteed that the input data have at least one fire demon.
Output
Print a string of minimum length, containing characters "L", "R" and "A" — the succession of actions leading to the required result.
If there are several possible answers, print any of them.
Examples
Input
3
1 0 1
Output
ARARARALLLA
Input
3
0 2 0
Output
ARARALAARALA | instruction | 0 | 59,393 | 2 | 118,786 |
Tags: greedy
Correct Solution:
```
n = int(input())
a = [0] * 1010
b = [0] * 2010
S = 1000000007
W=0
b = list(map(int,input().strip().split()))[:n]
for i in range(0,n):
a.insert(i,b[i])
while(not a[n-1]):
n-=1
for w in range(0,n+1):
for i in range(0,n):
b[i]=a[i]
for i in range(w,n):
if(b[i]):
b[i]-=1
w0=0
w1=0
la=0
for i in range(0,n):
w0+=max(0,b[i]-la)
w1 += b[i]
la = b[i]
T = 2*n+2+(n-w)+3*w1+2*w0
for i in range(0,n):
if(T<S):
S=T
W=w
for i in range(W,n):
if(a[i]):
a[i]-=1
for i in range(0,n):
while(a[i]):
j=i
while(a[j]):
a[j]-=1
j+=1
l = j - i
for k in range(0,l):
print("AR",end="")
print("A",end="")
for k in range(0,l):
print("L",end="")
print("A",end="")
print("AR",end="")
print("A",end="")
for i in range(W,n):
print("L",end="")
print("A",end="")
``` | output | 1 | 59,393 | 2 | 118,787 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Fire Lord attacked the Frost Kingdom. He has already got to the Ice Fortress, where the Snow Queen dwells. He arranged his army on a segment n in length not far from the city walls. And only the frost magician Solomon can save the Frost Kingdom.
<image>
The n-long segment is located at a distance equal exactly to 1 from the castle walls. It can be imaginarily divided into unit segments. On some of the unit segments fire demons are located — no more than one demon per position. Each demon is characterised by his strength - by some positive integer. We can regard the fire demons being idle.
Initially Solomon is positioned on the fortress wall. He can perform the following actions several times in a row:
* "L" — Solomon shifts one unit to the left. This movement cannot be performed on the castle wall.
* "R" — Solomon shifts one unit to the left. This movement cannot be performed if there's no ice block to the right.
* "A" — If there's nothing to the right of Solomon, then Solomon creates an ice block that immediately freezes to the block that Solomon is currently standing on. If there already is an ice block, then Solomon destroys it. At that the ice blocks to the right of the destroyed one can remain but they are left unsupported. Those ice blocks fall down.
Solomon spends exactly a second on each of these actions.
As the result of Solomon's actions, ice blocks' segments fall down. When an ice block falls on a fire demon, the block evaporates and the demon's strength is reduced by 1. When the demons' strength is equal to 0, the fire demon vanishes. The picture below shows how it happens. The ice block that falls on the position with no demon, breaks into lots of tiny pieces and vanishes without hurting anybody.
<image>
Help Solomon destroy all the Fire Lord's army in minimum time.
Input
The first line contains an integer n (1 ≤ n ≤ 1000). The next line contains n numbers, the i-th of them represents the strength of the fire demon standing of the i-th position, an integer from 1 to 100. If there's no demon on the i-th position, then the i-th number equals to 0. It is guaranteed that the input data have at least one fire demon.
Output
Print a string of minimum length, containing characters "L", "R" and "A" — the succession of actions leading to the required result.
If there are several possible answers, print any of them.
Examples
Input
3
1 0 1
Output
ARARARALLLA
Input
3
0 2 0
Output
ARARALAARALA
Submitted Solution:
```
n = int(input())
demons = [0, 0, *[int(_) for _ in input().split()]]
def trim_zeros_from_left():
# trim the demons list from the left
for _ in range(len(demons)):
if demons[-1] == 0:
del demons[-1]
else:
break
trim_zeros_from_left()
# move the first step
moves = 'AR' + 'AR' * (len(demons) - 3) + 'A'
solomons_index = len(demons) - 2
def find_nearest_stop():
maxi = 0
for i in range(len(demons)):
maxi = max(maxi, demons[-(i + 1)])
# print('maxi' + str(maxi))
if demons[-(i + 1)] == 0 and maxi > 1:
return len(demons) - (i + 1)
elif demons[-(i + 1)] == 1 and i != 0 and maxi > 1:
return len(demons) - (i + 1)
elif max(demons) == 1:
return demons.index(1) - 1
return 1
c = 0
# print(demons)
while True:
if c != 0:
moves += 'AR' * max(0, len(demons) - solomons_index - 2)
if solomons_index != len(demons) - 2:
moves += 'A'
solomons_index = len(demons) - 2
# print(moves)
c += 1
stop = find_nearest_stop()
# print(stop, solomons_index)
if solomons_index > stop - 1:
moves += 'L' * (solomons_index - stop + 1)
solomons_index = stop - 1
moves += 'A'
for _ in range(solomons_index + 1, len(demons)):
demons[_] = max(0, demons[_] - 1)
# print(stop, solomons_index)
if sum(demons) <= 0:
break
# trim the demons list from the left
# print(max(demons))
if max(demons) > 1:
for _ in range(len(demons[solomons_index:])):
if demons[-1] == 0:
del demons[-1]
else:
break
# print(demons, moves)
print(moves)
``` | instruction | 0 | 59,394 | 2 | 118,788 |
No | output | 1 | 59,394 | 2 | 118,789 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Fire Lord attacked the Frost Kingdom. He has already got to the Ice Fortress, where the Snow Queen dwells. He arranged his army on a segment n in length not far from the city walls. And only the frost magician Solomon can save the Frost Kingdom.
<image>
The n-long segment is located at a distance equal exactly to 1 from the castle walls. It can be imaginarily divided into unit segments. On some of the unit segments fire demons are located — no more than one demon per position. Each demon is characterised by his strength - by some positive integer. We can regard the fire demons being idle.
Initially Solomon is positioned on the fortress wall. He can perform the following actions several times in a row:
* "L" — Solomon shifts one unit to the left. This movement cannot be performed on the castle wall.
* "R" — Solomon shifts one unit to the left. This movement cannot be performed if there's no ice block to the right.
* "A" — If there's nothing to the right of Solomon, then Solomon creates an ice block that immediately freezes to the block that Solomon is currently standing on. If there already is an ice block, then Solomon destroys it. At that the ice blocks to the right of the destroyed one can remain but they are left unsupported. Those ice blocks fall down.
Solomon spends exactly a second on each of these actions.
As the result of Solomon's actions, ice blocks' segments fall down. When an ice block falls on a fire demon, the block evaporates and the demon's strength is reduced by 1. When the demons' strength is equal to 0, the fire demon vanishes. The picture below shows how it happens. The ice block that falls on the position with no demon, breaks into lots of tiny pieces and vanishes without hurting anybody.
<image>
Help Solomon destroy all the Fire Lord's army in minimum time.
Input
The first line contains an integer n (1 ≤ n ≤ 1000). The next line contains n numbers, the i-th of them represents the strength of the fire demon standing of the i-th position, an integer from 1 to 100. If there's no demon on the i-th position, then the i-th number equals to 0. It is guaranteed that the input data have at least one fire demon.
Output
Print a string of minimum length, containing characters "L", "R" and "A" — the succession of actions leading to the required result.
If there are several possible answers, print any of them.
Examples
Input
3
1 0 1
Output
ARARARALLLA
Input
3
0 2 0
Output
ARARALAARALA
Submitted Solution:
```
def cost_damage_with_mass_attack(n):
return 3 * n + 2
def cost_damage_with_single_attack(demons, n):
possible_mass_damage = 0
cost = 0
k = 0
for i in range(n + 1):
if demons[i] != 0:
possible_mass_damage += 1
while possible_mass_damage > 0:
if demons[k] != 0:
if demons[k] > possible_mass_damage:
cost += 5 + 5 * (possible_mass_damage - 1)
return cost
elif demons[k] == possible_mass_damage:
cost += 5 + 5 * (possible_mass_damage - 1)
return cost
else:
if k == n:
cost += 5 + 5 * (demons[k] - 1)
return cost
else:
cost += 2 + 5 * demons[k]
possible_mass_damage -= demons[k]
k += 1
else:
cost += 2
k += 1
def mass_attack(demons, n):
for i in range(n):
if demons[i] != 0:
demons[i] -= 1
return 'AR' * n + 'A' + 'L' * n + 'A'
def search_last_demon(demons):
for i in range(len(demons) - 1, -1, -1):
if demons[i] != 0:
return i
return -1
n = int(input())
demons = [int(x) for x in input().split()]
move = 'AR'
attack = 'ALA'
result = ''
flag = False
n = search_last_demon(demons)
while cost_damage_with_mass_attack(n + 1) < cost_damage_with_single_attack(demons, n):
result += mass_attack(demons, n + 1)
n = search_last_demon(demons)
if n == -1:
break
if n == -1:
print(result)
else:
for i in range(n + 1):
if demons[i] != 0:
if i == n:
result += move + (attack + move) * (demons[i] - 1) + attack
else:
result += move + (attack + move) * demons[i]
else:
result += move
print(result)
``` | instruction | 0 | 59,395 | 2 | 118,790 |
No | output | 1 | 59,395 | 2 | 118,791 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Fire Lord attacked the Frost Kingdom. He has already got to the Ice Fortress, where the Snow Queen dwells. He arranged his army on a segment n in length not far from the city walls. And only the frost magician Solomon can save the Frost Kingdom.
<image>
The n-long segment is located at a distance equal exactly to 1 from the castle walls. It can be imaginarily divided into unit segments. On some of the unit segments fire demons are located — no more than one demon per position. Each demon is characterised by his strength - by some positive integer. We can regard the fire demons being idle.
Initially Solomon is positioned on the fortress wall. He can perform the following actions several times in a row:
* "L" — Solomon shifts one unit to the left. This movement cannot be performed on the castle wall.
* "R" — Solomon shifts one unit to the left. This movement cannot be performed if there's no ice block to the right.
* "A" — If there's nothing to the right of Solomon, then Solomon creates an ice block that immediately freezes to the block that Solomon is currently standing on. If there already is an ice block, then Solomon destroys it. At that the ice blocks to the right of the destroyed one can remain but they are left unsupported. Those ice blocks fall down.
Solomon spends exactly a second on each of these actions.
As the result of Solomon's actions, ice blocks' segments fall down. When an ice block falls on a fire demon, the block evaporates and the demon's strength is reduced by 1. When the demons' strength is equal to 0, the fire demon vanishes. The picture below shows how it happens. The ice block that falls on the position with no demon, breaks into lots of tiny pieces and vanishes without hurting anybody.
<image>
Help Solomon destroy all the Fire Lord's army in minimum time.
Input
The first line contains an integer n (1 ≤ n ≤ 1000). The next line contains n numbers, the i-th of them represents the strength of the fire demon standing of the i-th position, an integer from 1 to 100. If there's no demon on the i-th position, then the i-th number equals to 0. It is guaranteed that the input data have at least one fire demon.
Output
Print a string of minimum length, containing characters "L", "R" and "A" — the succession of actions leading to the required result.
If there are several possible answers, print any of them.
Examples
Input
3
1 0 1
Output
ARARARALLLA
Input
3
0 2 0
Output
ARARALAARALA
Submitted Solution:
```
n = int(input())
demons = [int(_) for _ in input().split()]
demons_map = {0: 0, 1: 0}
# demons_map = {n: v for (n, v) in enumerate([int(_) for _ in input().split()], start=2)}
for iii in range(2, n + 2):
demons_map[iii] = demons[iii - 2]
# print(demons_map)
def trim_zeros_from_left():
# trim the demons list from the left
for k in reversed(list(demons_map.keys())):
if demons_map[k] == 0:
del demons_map[k]
else:
break
# print(demons_map)
trim_zeros_from_left()
# move the first step
moves = 'AR' + 'AR' * (len(demons_map.keys()) - 3) + 'A'
solomons_index = len(demons_map.keys()) - 2
# print(demons_map)
def find_nearest_stop():
maxi, ctart = 0, 0
for kl in reversed(list(demons_map.keys())):
maxi = max(maxi, demons_map[kl])
if demons_map[kl] == 0 and maxi > 1:
return kl
elif demons_map[kl] == 1 and ctart != 0 and maxi > 1:
return kl
elif demons_map[max(demons_map)] == 1:
for ke, v in demons_map.items():
if v == 1:
return ke - 1
ctart += 1
return 1
c = 0
# print(demons_map)
while True:
if c != 0:
moves += 'AR' * max(0, len(demons_map) - solomons_index - 2)
if solomons_index != len(demons_map) - 2:
moves += 'A'
solomons_index = len(demons_map) - 2
# print(moves)
c += 1
stop = find_nearest_stop()
# print(stop, solomons_index)
if solomons_index > stop - 1:
moves += 'L' * (solomons_index - stop + 1)
solomons_index = stop - 1
moves += 'A'
for _ in range(solomons_index + 2, len(demons_map)):
demons_map[_] = max(0, demons_map[_] - 1)
# print(stop, solomons_index)
if sum(demons_map.values()) <= 0:
break
# trim the demons list from the left
# print(demons_map[max(demons_map)])
if demons_map[max(demons_map)] > 0:
for k in reversed(list(demons_map.keys())):
if demons_map[k] == 0 and k != solomons_index:
del demons_map[k]
else:
break
# print(demons_map, moves)
# print(demons_map)
print(moves)
``` | instruction | 0 | 59,396 | 2 | 118,792 |
No | output | 1 | 59,396 | 2 | 118,793 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Fire Lord attacked the Frost Kingdom. He has already got to the Ice Fortress, where the Snow Queen dwells. He arranged his army on a segment n in length not far from the city walls. And only the frost magician Solomon can save the Frost Kingdom.
<image>
The n-long segment is located at a distance equal exactly to 1 from the castle walls. It can be imaginarily divided into unit segments. On some of the unit segments fire demons are located — no more than one demon per position. Each demon is characterised by his strength - by some positive integer. We can regard the fire demons being idle.
Initially Solomon is positioned on the fortress wall. He can perform the following actions several times in a row:
* "L" — Solomon shifts one unit to the left. This movement cannot be performed on the castle wall.
* "R" — Solomon shifts one unit to the left. This movement cannot be performed if there's no ice block to the right.
* "A" — If there's nothing to the right of Solomon, then Solomon creates an ice block that immediately freezes to the block that Solomon is currently standing on. If there already is an ice block, then Solomon destroys it. At that the ice blocks to the right of the destroyed one can remain but they are left unsupported. Those ice blocks fall down.
Solomon spends exactly a second on each of these actions.
As the result of Solomon's actions, ice blocks' segments fall down. When an ice block falls on a fire demon, the block evaporates and the demon's strength is reduced by 1. When the demons' strength is equal to 0, the fire demon vanishes. The picture below shows how it happens. The ice block that falls on the position with no demon, breaks into lots of tiny pieces and vanishes without hurting anybody.
<image>
Help Solomon destroy all the Fire Lord's army in minimum time.
Input
The first line contains an integer n (1 ≤ n ≤ 1000). The next line contains n numbers, the i-th of them represents the strength of the fire demon standing of the i-th position, an integer from 1 to 100. If there's no demon on the i-th position, then the i-th number equals to 0. It is guaranteed that the input data have at least one fire demon.
Output
Print a string of minimum length, containing characters "L", "R" and "A" — the succession of actions leading to the required result.
If there are several possible answers, print any of them.
Examples
Input
3
1 0 1
Output
ARARARALLLA
Input
3
0 2 0
Output
ARARALAARALA
Submitted Solution:
```
def cost_damage_with_mass_attack(demons):
return 3 * len(demons) + 2
def cost_damage_with_single_attack(demons, n):
possible_mass_damage = 0
for x in demons:
if x != 0:
possible_mass_damage += 1
cost = 0
k = 0
while possible_mass_damage > 0:
if demons[k] != 0:
if k + 1 == n:
cost += 5 + (5 * demons[k] - 1)
else:
cost += 2 + 5 * demons[k]
possible_mass_damage -= demons[k]
k += 1
else:
cost += 2
k += 1
return cost
def mass_attack(demons):
for i in range(len(demons)):
if demons[i] != 0:
demons[i] -= 1
return 'AR' * len(demons) + 'A' + 'L' * len(demons) + 'A'
n = int(input())
demons = [int(x) for x in input().split()]
move = 'AR'
attack = 'ALA'
result = ''
for i in range((len(demons) - 1), -1, -1):
if demons[i] != 0:
n = i
break
while cost_damage_with_mass_attack(demons) <= cost_damage_with_single_attack(demons, n):
result += mass_attack(demons)
for i in range((len(demons) - 1), -1, -1):
if demons[i] != 0:
n = i
break
else:
n = i - 1
if n == -1:
print(result)
else:
for i in range(n+1):
if demons[i] != 0:
if i == n:
result += move + (attack + move) * (demons[i] - 1) + attack
else:
result += move + (attack + move) * demons[i]
else:
result += move
print(result)
``` | instruction | 0 | 59,397 | 2 | 118,794 |
No | output | 1 | 59,397 | 2 | 118,795 |
Provide a correct Python 3 solution for this coding contest problem.
Serval is fighting with a monster.
The health of the monster is H.
In one attack, Serval can decrease the monster's health by A. There is no other way to decrease the monster's health.
Serval wins when the monster's health becomes 0 or below.
Find the number of attacks Serval needs to make before winning.
Constraints
* 1 \leq H \leq 10^4
* 1 \leq A \leq 10^4
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
H A
Output
Print the number of attacks Serval needs to make before winning.
Examples
Input
10 4
Output
3
Input
1 10000
Output
1
Input
10000 1
Output
10000 | instruction | 0 | 59,433 | 2 | 118,866 |
"Correct Solution:
```
a, b = map(int, input().split())
c = -(-a // b)
print(c)
``` | output | 1 | 59,433 | 2 | 118,867 |
Provide a correct Python 3 solution for this coding contest problem.
Serval is fighting with a monster.
The health of the monster is H.
In one attack, Serval can decrease the monster's health by A. There is no other way to decrease the monster's health.
Serval wins when the monster's health becomes 0 or below.
Find the number of attacks Serval needs to make before winning.
Constraints
* 1 \leq H \leq 10^4
* 1 \leq A \leq 10^4
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
H A
Output
Print the number of attacks Serval needs to make before winning.
Examples
Input
10 4
Output
3
Input
1 10000
Output
1
Input
10000 1
Output
10000 | instruction | 0 | 59,434 | 2 | 118,868 |
"Correct Solution:
```
h, a = map(int, input().split())
print(int((a + h - 1) / a))
``` | output | 1 | 59,434 | 2 | 118,869 |
Provide a correct Python 3 solution for this coding contest problem.
Serval is fighting with a monster.
The health of the monster is H.
In one attack, Serval can decrease the monster's health by A. There is no other way to decrease the monster's health.
Serval wins when the monster's health becomes 0 or below.
Find the number of attacks Serval needs to make before winning.
Constraints
* 1 \leq H \leq 10^4
* 1 \leq A \leq 10^4
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
H A
Output
Print the number of attacks Serval needs to make before winning.
Examples
Input
10 4
Output
3
Input
1 10000
Output
1
Input
10000 1
Output
10000 | instruction | 0 | 59,435 | 2 | 118,870 |
"Correct Solution:
```
h,a=map(int,input().split())
print((a+h-1)//a)
``` | output | 1 | 59,435 | 2 | 118,871 |
Provide a correct Python 3 solution for this coding contest problem.
Serval is fighting with a monster.
The health of the monster is H.
In one attack, Serval can decrease the monster's health by A. There is no other way to decrease the monster's health.
Serval wins when the monster's health becomes 0 or below.
Find the number of attacks Serval needs to make before winning.
Constraints
* 1 \leq H \leq 10^4
* 1 \leq A \leq 10^4
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
H A
Output
Print the number of attacks Serval needs to make before winning.
Examples
Input
10 4
Output
3
Input
1 10000
Output
1
Input
10000 1
Output
10000 | instruction | 0 | 59,436 | 2 | 118,872 |
"Correct Solution:
```
h,a=map(int,input().split())
x=0
if h%a>0:
x=1
print(h//a+x)
``` | output | 1 | 59,436 | 2 | 118,873 |
Provide a correct Python 3 solution for this coding contest problem.
Serval is fighting with a monster.
The health of the monster is H.
In one attack, Serval can decrease the monster's health by A. There is no other way to decrease the monster's health.
Serval wins when the monster's health becomes 0 or below.
Find the number of attacks Serval needs to make before winning.
Constraints
* 1 \leq H \leq 10^4
* 1 \leq A \leq 10^4
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
H A
Output
Print the number of attacks Serval needs to make before winning.
Examples
Input
10 4
Output
3
Input
1 10000
Output
1
Input
10000 1
Output
10000 | instruction | 0 | 59,437 | 2 | 118,874 |
"Correct Solution:
```
H,A=map(int,input().split())
print(int((H-0.5)//A+1))
``` | output | 1 | 59,437 | 2 | 118,875 |
Provide a correct Python 3 solution for this coding contest problem.
Serval is fighting with a monster.
The health of the monster is H.
In one attack, Serval can decrease the monster's health by A. There is no other way to decrease the monster's health.
Serval wins when the monster's health becomes 0 or below.
Find the number of attacks Serval needs to make before winning.
Constraints
* 1 \leq H \leq 10^4
* 1 \leq A \leq 10^4
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
H A
Output
Print the number of attacks Serval needs to make before winning.
Examples
Input
10 4
Output
3
Input
1 10000
Output
1
Input
10000 1
Output
10000 | instruction | 0 | 59,438 | 2 | 118,876 |
"Correct Solution:
```
import math
a,b=map(float,input().split())
print(math.ceil(a/b))
``` | output | 1 | 59,438 | 2 | 118,877 |
Provide a correct Python 3 solution for this coding contest problem.
Serval is fighting with a monster.
The health of the monster is H.
In one attack, Serval can decrease the monster's health by A. There is no other way to decrease the monster's health.
Serval wins when the monster's health becomes 0 or below.
Find the number of attacks Serval needs to make before winning.
Constraints
* 1 \leq H \leq 10^4
* 1 \leq A \leq 10^4
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
H A
Output
Print the number of attacks Serval needs to make before winning.
Examples
Input
10 4
Output
3
Input
1 10000
Output
1
Input
10000 1
Output
10000 | instruction | 0 | 59,439 | 2 | 118,878 |
"Correct Solution:
```
h,a = map(int,input().split())
print(h//a+(h%a!=0))
``` | output | 1 | 59,439 | 2 | 118,879 |
Provide a correct Python 3 solution for this coding contest problem.
Serval is fighting with a monster.
The health of the monster is H.
In one attack, Serval can decrease the monster's health by A. There is no other way to decrease the monster's health.
Serval wins when the monster's health becomes 0 or below.
Find the number of attacks Serval needs to make before winning.
Constraints
* 1 \leq H \leq 10^4
* 1 \leq A \leq 10^4
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
H A
Output
Print the number of attacks Serval needs to make before winning.
Examples
Input
10 4
Output
3
Input
1 10000
Output
1
Input
10000 1
Output
10000 | instruction | 0 | 59,440 | 2 | 118,880 |
"Correct Solution:
```
h,a=map(int,input().split());print(h//a if h%a==0 else 1+h//a)
``` | output | 1 | 59,440 | 2 | 118,881 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Serval is fighting with a monster.
The health of the monster is H.
In one attack, Serval can decrease the monster's health by A. There is no other way to decrease the monster's health.
Serval wins when the monster's health becomes 0 or below.
Find the number of attacks Serval needs to make before winning.
Constraints
* 1 \leq H \leq 10^4
* 1 \leq A \leq 10^4
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
H A
Output
Print the number of attacks Serval needs to make before winning.
Examples
Input
10 4
Output
3
Input
1 10000
Output
1
Input
10000 1
Output
10000
Submitted Solution:
```
h,a=map(int,input().split())
print(int(h/a+0.99995))
``` | instruction | 0 | 59,441 | 2 | 118,882 |
Yes | output | 1 | 59,441 | 2 | 118,883 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Serval is fighting with a monster.
The health of the monster is H.
In one attack, Serval can decrease the monster's health by A. There is no other way to decrease the monster's health.
Serval wins when the monster's health becomes 0 or below.
Find the number of attacks Serval needs to make before winning.
Constraints
* 1 \leq H \leq 10^4
* 1 \leq A \leq 10^4
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
H A
Output
Print the number of attacks Serval needs to make before winning.
Examples
Input
10 4
Output
3
Input
1 10000
Output
1
Input
10000 1
Output
10000
Submitted Solution:
```
h,a = tuple(map(int,input().rstrip().split()))
print((h+a-1)//a)
``` | instruction | 0 | 59,442 | 2 | 118,884 |
Yes | output | 1 | 59,442 | 2 | 118,885 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Serval is fighting with a monster.
The health of the monster is H.
In one attack, Serval can decrease the monster's health by A. There is no other way to decrease the monster's health.
Serval wins when the monster's health becomes 0 or below.
Find the number of attacks Serval needs to make before winning.
Constraints
* 1 \leq H \leq 10^4
* 1 \leq A \leq 10^4
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
H A
Output
Print the number of attacks Serval needs to make before winning.
Examples
Input
10 4
Output
3
Input
1 10000
Output
1
Input
10000 1
Output
10000
Submitted Solution:
```
H, A = map(int, input().split())
print(H // A + bool(H % A))
``` | instruction | 0 | 59,443 | 2 | 118,886 |
Yes | output | 1 | 59,443 | 2 | 118,887 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Serval is fighting with a monster.
The health of the monster is H.
In one attack, Serval can decrease the monster's health by A. There is no other way to decrease the monster's health.
Serval wins when the monster's health becomes 0 or below.
Find the number of attacks Serval needs to make before winning.
Constraints
* 1 \leq H \leq 10^4
* 1 \leq A \leq 10^4
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
H A
Output
Print the number of attacks Serval needs to make before winning.
Examples
Input
10 4
Output
3
Input
1 10000
Output
1
Input
10000 1
Output
10000
Submitted Solution:
```
H,A=map(int,input().split());
print((H+A-1)//A);
``` | instruction | 0 | 59,444 | 2 | 118,888 |
Yes | output | 1 | 59,444 | 2 | 118,889 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Serval is fighting with a monster.
The health of the monster is H.
In one attack, Serval can decrease the monster's health by A. There is no other way to decrease the monster's health.
Serval wins when the monster's health becomes 0 or below.
Find the number of attacks Serval needs to make before winning.
Constraints
* 1 \leq H \leq 10^4
* 1 \leq A \leq 10^4
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
H A
Output
Print the number of attacks Serval needs to make before winning.
Examples
Input
10 4
Output
3
Input
1 10000
Output
1
Input
10000 1
Output
10000
Submitted Solution:
```
H , A = [int(x) for x in input().split()]
attack = True
count = 0
while(attack):
H = H - A
count = count + 1
if H < 0:
attack = False
print(count - 1)
``` | instruction | 0 | 59,445 | 2 | 118,890 |
No | output | 1 | 59,445 | 2 | 118,891 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Serval is fighting with a monster.
The health of the monster is H.
In one attack, Serval can decrease the monster's health by A. There is no other way to decrease the monster's health.
Serval wins when the monster's health becomes 0 or below.
Find the number of attacks Serval needs to make before winning.
Constraints
* 1 \leq H \leq 10^4
* 1 \leq A \leq 10^4
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
H A
Output
Print the number of attacks Serval needs to make before winning.
Examples
Input
10 4
Output
3
Input
1 10000
Output
1
Input
10000 1
Output
10000
Submitted Solution:
```
H,A = map(int,input().split())
print(H//A if H%A=0 else H//A+1)
``` | instruction | 0 | 59,446 | 2 | 118,892 |
No | output | 1 | 59,446 | 2 | 118,893 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Serval is fighting with a monster.
The health of the monster is H.
In one attack, Serval can decrease the monster's health by A. There is no other way to decrease the monster's health.
Serval wins when the monster's health becomes 0 or below.
Find the number of attacks Serval needs to make before winning.
Constraints
* 1 \leq H \leq 10^4
* 1 \leq A \leq 10^4
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
H A
Output
Print the number of attacks Serval needs to make before winning.
Examples
Input
10 4
Output
3
Input
1 10000
Output
1
Input
10000 1
Output
10000
Submitted Solution:
```
h,a=map(int,input.split())
if h>a:
print(h//a)
if h<a:
print(1)
``` | instruction | 0 | 59,447 | 2 | 118,894 |
No | output | 1 | 59,447 | 2 | 118,895 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Serval is fighting with a monster.
The health of the monster is H.
In one attack, Serval can decrease the monster's health by A. There is no other way to decrease the monster's health.
Serval wins when the monster's health becomes 0 or below.
Find the number of attacks Serval needs to make before winning.
Constraints
* 1 \leq H \leq 10^4
* 1 \leq A \leq 10^4
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
H A
Output
Print the number of attacks Serval needs to make before winning.
Examples
Input
10 4
Output
3
Input
1 10000
Output
1
Input
10000 1
Output
10000
Submitted Solution:
```
H,N=map(int, input().split())
A = list(map(int, input().split()))
if(sum(A) > H):
print("Yes")
else:
print("No")
``` | instruction | 0 | 59,448 | 2 | 118,896 |
No | output | 1 | 59,448 | 2 | 118,897 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.