message stringlengths 2 48.6k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 318 108k | cluster float64 8 8 | __index_level_0__ int64 636 217k |
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
A very brave explorer Petya once decided to explore Paris catacombs. Since Petya is not really experienced, his exploration is just walking through the catacombs.
Catacombs consist of several rooms and bidirectional passages between some pairs of them. Some passages can connect a room to itself and since the passages are built on different depths they do not intersect each other. Every minute Petya arbitrary chooses a passage from the room he is currently in and then reaches the room on the other end of the passage in exactly one minute. When he enters a room at minute i, he makes a note in his logbook with number ti:
* If Petya has visited this room before, he writes down the minute he was in this room last time;
* Otherwise, Petya writes down an arbitrary non-negative integer strictly less than current minute i.
Initially, Petya was in one of the rooms at minute 0, he didn't write down number t0.
At some point during his wandering Petya got tired, threw out his logbook and went home. Vasya found his logbook and now he is curious: what is the minimum possible number of rooms in Paris catacombs according to Petya's logbook?
Input
The first line contains a single integer n (1 β€ n β€ 2Β·105) β then number of notes in Petya's logbook.
The second line contains n non-negative integers t1, t2, ..., tn (0 β€ ti < i) β notes in the logbook.
Output
In the only line print a single integer β the minimum possible number of rooms in Paris catacombs.
Examples
Input
2
0 0
Output
2
Input
5
0 1 0 1 3
Output
3
Note
In the first sample, sequence of rooms Petya visited could be, for example 1 β 1 β 2, 1 β 2 β 1 or 1 β 2 β 3. The minimum possible number of rooms is 2.
In the second sample, the sequence could be 1 β 2 β 3 β 1 β 2 β 1. | instruction | 0 | 16,520 | 8 | 33,040 |
Tags: dsu, greedy, implementation, trees
Correct Solution:
```
from sys import stdin, stdout
n=int(stdin.readline())
a=[int(x) for x in stdin.readline().split()]
l=len(a)
b=len(set(a))
print(l-b+1)
``` | output | 1 | 16,520 | 8 | 33,041 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A very brave explorer Petya once decided to explore Paris catacombs. Since Petya is not really experienced, his exploration is just walking through the catacombs.
Catacombs consist of several rooms and bidirectional passages between some pairs of them. Some passages can connect a room to itself and since the passages are built on different depths they do not intersect each other. Every minute Petya arbitrary chooses a passage from the room he is currently in and then reaches the room on the other end of the passage in exactly one minute. When he enters a room at minute i, he makes a note in his logbook with number ti:
* If Petya has visited this room before, he writes down the minute he was in this room last time;
* Otherwise, Petya writes down an arbitrary non-negative integer strictly less than current minute i.
Initially, Petya was in one of the rooms at minute 0, he didn't write down number t0.
At some point during his wandering Petya got tired, threw out his logbook and went home. Vasya found his logbook and now he is curious: what is the minimum possible number of rooms in Paris catacombs according to Petya's logbook?
Input
The first line contains a single integer n (1 β€ n β€ 2Β·105) β then number of notes in Petya's logbook.
The second line contains n non-negative integers t1, t2, ..., tn (0 β€ ti < i) β notes in the logbook.
Output
In the only line print a single integer β the minimum possible number of rooms in Paris catacombs.
Examples
Input
2
0 0
Output
2
Input
5
0 1 0 1 3
Output
3
Note
In the first sample, sequence of rooms Petya visited could be, for example 1 β 1 β 2, 1 β 2 β 1 or 1 β 2 β 3. The minimum possible number of rooms is 2.
In the second sample, the sequence could be 1 β 2 β 3 β 1 β 2 β 1. | instruction | 0 | 16,521 | 8 | 33,042 |
Tags: dsu, greedy, implementation, trees
Correct Solution:
```
n = int(input())
inp = list(map(int, input().split()))
arr = [0]
count = 1
time = 1
dict = {0: 0}
for i in inp:
if dict[arr[i]] != i:
dict[count] = time
arr.append(count)
count += 1
else:
dict[arr[i]] = time
arr.append(arr[i])
time += 1
print(count)
``` | output | 1 | 16,521 | 8 | 33,043 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A very brave explorer Petya once decided to explore Paris catacombs. Since Petya is not really experienced, his exploration is just walking through the catacombs.
Catacombs consist of several rooms and bidirectional passages between some pairs of them. Some passages can connect a room to itself and since the passages are built on different depths they do not intersect each other. Every minute Petya arbitrary chooses a passage from the room he is currently in and then reaches the room on the other end of the passage in exactly one minute. When he enters a room at minute i, he makes a note in his logbook with number ti:
* If Petya has visited this room before, he writes down the minute he was in this room last time;
* Otherwise, Petya writes down an arbitrary non-negative integer strictly less than current minute i.
Initially, Petya was in one of the rooms at minute 0, he didn't write down number t0.
At some point during his wandering Petya got tired, threw out his logbook and went home. Vasya found his logbook and now he is curious: what is the minimum possible number of rooms in Paris catacombs according to Petya's logbook?
Input
The first line contains a single integer n (1 β€ n β€ 2Β·105) β then number of notes in Petya's logbook.
The second line contains n non-negative integers t1, t2, ..., tn (0 β€ ti < i) β notes in the logbook.
Output
In the only line print a single integer β the minimum possible number of rooms in Paris catacombs.
Examples
Input
2
0 0
Output
2
Input
5
0 1 0 1 3
Output
3
Note
In the first sample, sequence of rooms Petya visited could be, for example 1 β 1 β 2, 1 β 2 β 1 or 1 β 2 β 3. The minimum possible number of rooms is 2.
In the second sample, the sequence could be 1 β 2 β 3 β 1 β 2 β 1. | instruction | 0 | 16,522 | 8 | 33,044 |
Tags: dsu, greedy, implementation, trees
Correct Solution:
```
n, data = int(input()), list(map(int, input().split()))
time = [0] + [-100] * (3 * (10 ** 5))
rooms = [0]
for i in range(1, n + 1):
if(time[data[i - 1]] != -100 and rooms[time[data[i - 1]]] == data[i - 1]):
rooms[time[data[i - 1]]] = i
time[i] = time[data[i - 1]]
else:
rooms.append(i)
time[i] = len(rooms) - 1
print(len(rooms))
``` | output | 1 | 16,522 | 8 | 33,045 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A very brave explorer Petya once decided to explore Paris catacombs. Since Petya is not really experienced, his exploration is just walking through the catacombs.
Catacombs consist of several rooms and bidirectional passages between some pairs of them. Some passages can connect a room to itself and since the passages are built on different depths they do not intersect each other. Every minute Petya arbitrary chooses a passage from the room he is currently in and then reaches the room on the other end of the passage in exactly one minute. When he enters a room at minute i, he makes a note in his logbook with number ti:
* If Petya has visited this room before, he writes down the minute he was in this room last time;
* Otherwise, Petya writes down an arbitrary non-negative integer strictly less than current minute i.
Initially, Petya was in one of the rooms at minute 0, he didn't write down number t0.
At some point during his wandering Petya got tired, threw out his logbook and went home. Vasya found his logbook and now he is curious: what is the minimum possible number of rooms in Paris catacombs according to Petya's logbook?
Input
The first line contains a single integer n (1 β€ n β€ 2Β·105) β then number of notes in Petya's logbook.
The second line contains n non-negative integers t1, t2, ..., tn (0 β€ ti < i) β notes in the logbook.
Output
In the only line print a single integer β the minimum possible number of rooms in Paris catacombs.
Examples
Input
2
0 0
Output
2
Input
5
0 1 0 1 3
Output
3
Note
In the first sample, sequence of rooms Petya visited could be, for example 1 β 1 β 2, 1 β 2 β 1 or 1 β 2 β 3. The minimum possible number of rooms is 2.
In the second sample, the sequence could be 1 β 2 β 3 β 1 β 2 β 1.
Submitted Solution:
```
def main():
n = int(input())
a = [0]
a += list(map(int, input().split()))
p = [0] * 200001
p[1] = 0
k = [-1] * 200001
k[0] = 1
ans = 1
cnt = 1
for i in range(1, n + 1):
if (i == 1):
if (a[i] == 1):
cnt += 1
k[i] = cnt
p[cnt] = i
ans += 1
else:
k[i] = k[a[a[i]]]
p[k[i]] = i
elif (p[k[a[i]]] != a[i]):
cnt += 1
k[i] = cnt
p[cnt] = i
ans += 1
else:
k[i] = k[a[i]]
p[k[i]] = i
print(ans)
main()
``` | instruction | 0 | 16,523 | 8 | 33,046 |
Yes | output | 1 | 16,523 | 8 | 33,047 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A very brave explorer Petya once decided to explore Paris catacombs. Since Petya is not really experienced, his exploration is just walking through the catacombs.
Catacombs consist of several rooms and bidirectional passages between some pairs of them. Some passages can connect a room to itself and since the passages are built on different depths they do not intersect each other. Every minute Petya arbitrary chooses a passage from the room he is currently in and then reaches the room on the other end of the passage in exactly one minute. When he enters a room at minute i, he makes a note in his logbook with number ti:
* If Petya has visited this room before, he writes down the minute he was in this room last time;
* Otherwise, Petya writes down an arbitrary non-negative integer strictly less than current minute i.
Initially, Petya was in one of the rooms at minute 0, he didn't write down number t0.
At some point during his wandering Petya got tired, threw out his logbook and went home. Vasya found his logbook and now he is curious: what is the minimum possible number of rooms in Paris catacombs according to Petya's logbook?
Input
The first line contains a single integer n (1 β€ n β€ 2Β·105) β then number of notes in Petya's logbook.
The second line contains n non-negative integers t1, t2, ..., tn (0 β€ ti < i) β notes in the logbook.
Output
In the only line print a single integer β the minimum possible number of rooms in Paris catacombs.
Examples
Input
2
0 0
Output
2
Input
5
0 1 0 1 3
Output
3
Note
In the first sample, sequence of rooms Petya visited could be, for example 1 β 1 β 2, 1 β 2 β 1 or 1 β 2 β 3. The minimum possible number of rooms is 2.
In the second sample, the sequence could be 1 β 2 β 3 β 1 β 2 β 1.
Submitted Solution:
```
# _
#####################################################################################################################
class Petya_sNotes(object):
def __init__(self, nVisits, notesContent):
self.nVisits = nVisits
self.notesContent = notesContent
def min_nRoomsVisited(self):
min_nRooms = 1
recordOfLatestMinutes = {x for x in range(self.nVisits)}
for iMinute in range(self.nVisits):
note = int(self.notesContent[iMinute])
if note not in recordOfLatestMinutes:
min_nRooms += 1
else:
recordOfLatestMinutes.remove(note)
return min_nRooms
print(Petya_sNotes(int(input()), input().split()).min_nRoomsVisited())
``` | instruction | 0 | 16,524 | 8 | 33,048 |
Yes | output | 1 | 16,524 | 8 | 33,049 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A very brave explorer Petya once decided to explore Paris catacombs. Since Petya is not really experienced, his exploration is just walking through the catacombs.
Catacombs consist of several rooms and bidirectional passages between some pairs of them. Some passages can connect a room to itself and since the passages are built on different depths they do not intersect each other. Every minute Petya arbitrary chooses a passage from the room he is currently in and then reaches the room on the other end of the passage in exactly one minute. When he enters a room at minute i, he makes a note in his logbook with number ti:
* If Petya has visited this room before, he writes down the minute he was in this room last time;
* Otherwise, Petya writes down an arbitrary non-negative integer strictly less than current minute i.
Initially, Petya was in one of the rooms at minute 0, he didn't write down number t0.
At some point during his wandering Petya got tired, threw out his logbook and went home. Vasya found his logbook and now he is curious: what is the minimum possible number of rooms in Paris catacombs according to Petya's logbook?
Input
The first line contains a single integer n (1 β€ n β€ 2Β·105) β then number of notes in Petya's logbook.
The second line contains n non-negative integers t1, t2, ..., tn (0 β€ ti < i) β notes in the logbook.
Output
In the only line print a single integer β the minimum possible number of rooms in Paris catacombs.
Examples
Input
2
0 0
Output
2
Input
5
0 1 0 1 3
Output
3
Note
In the first sample, sequence of rooms Petya visited could be, for example 1 β 1 β 2, 1 β 2 β 1 or 1 β 2 β 3. The minimum possible number of rooms is 2.
In the second sample, the sequence could be 1 β 2 β 3 β 1 β 2 β 1.
Submitted Solution:
```
am = int(input())
arr = list(map(int,input().split()))
was = [False]*am
t = 0
for i in range(am):
if arr[i] == 0:
t+=1
was[i] = True
continue
if was[arr[i]-1]:
was[arr[i]-1] = False
was[i] = True
else:
was[i] = True
t+=1
print(t)
``` | instruction | 0 | 16,525 | 8 | 33,050 |
Yes | output | 1 | 16,525 | 8 | 33,051 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A very brave explorer Petya once decided to explore Paris catacombs. Since Petya is not really experienced, his exploration is just walking through the catacombs.
Catacombs consist of several rooms and bidirectional passages between some pairs of them. Some passages can connect a room to itself and since the passages are built on different depths they do not intersect each other. Every minute Petya arbitrary chooses a passage from the room he is currently in and then reaches the room on the other end of the passage in exactly one minute. When he enters a room at minute i, he makes a note in his logbook with number ti:
* If Petya has visited this room before, he writes down the minute he was in this room last time;
* Otherwise, Petya writes down an arbitrary non-negative integer strictly less than current minute i.
Initially, Petya was in one of the rooms at minute 0, he didn't write down number t0.
At some point during his wandering Petya got tired, threw out his logbook and went home. Vasya found his logbook and now he is curious: what is the minimum possible number of rooms in Paris catacombs according to Petya's logbook?
Input
The first line contains a single integer n (1 β€ n β€ 2Β·105) β then number of notes in Petya's logbook.
The second line contains n non-negative integers t1, t2, ..., tn (0 β€ ti < i) β notes in the logbook.
Output
In the only line print a single integer β the minimum possible number of rooms in Paris catacombs.
Examples
Input
2
0 0
Output
2
Input
5
0 1 0 1 3
Output
3
Note
In the first sample, sequence of rooms Petya visited could be, for example 1 β 1 β 2, 1 β 2 β 1 or 1 β 2 β 3. The minimum possible number of rooms is 2.
In the second sample, the sequence could be 1 β 2 β 3 β 1 β 2 β 1.
Submitted Solution:
```
# Author: S Mahesh Raju
# Username: maheshraju2020
# Created on: 25/09/2020 16:58:42
from sys import stdin, stdout, setrecursionlimit
import heapq
from math import gcd, ceil, sqrt
from collections import Counter, deque
from bisect import bisect_left, bisect_right
from itertools import combinations, permutations
ii1 = lambda: int(stdin.readline().strip())
is1 = lambda: stdin.readline().strip()
iia = lambda: list(map(int, stdin.readline().strip().split()))
isa = lambda: stdin.readline().strip().split()
setrecursionlimit(100000)
mod = 1000000007
n = ii1()
arr = iia()
print(n - len(set(arr)) + 1)
``` | instruction | 0 | 16,526 | 8 | 33,052 |
Yes | output | 1 | 16,526 | 8 | 33,053 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A very brave explorer Petya once decided to explore Paris catacombs. Since Petya is not really experienced, his exploration is just walking through the catacombs.
Catacombs consist of several rooms and bidirectional passages between some pairs of them. Some passages can connect a room to itself and since the passages are built on different depths they do not intersect each other. Every minute Petya arbitrary chooses a passage from the room he is currently in and then reaches the room on the other end of the passage in exactly one minute. When he enters a room at minute i, he makes a note in his logbook with number ti:
* If Petya has visited this room before, he writes down the minute he was in this room last time;
* Otherwise, Petya writes down an arbitrary non-negative integer strictly less than current minute i.
Initially, Petya was in one of the rooms at minute 0, he didn't write down number t0.
At some point during his wandering Petya got tired, threw out his logbook and went home. Vasya found his logbook and now he is curious: what is the minimum possible number of rooms in Paris catacombs according to Petya's logbook?
Input
The first line contains a single integer n (1 β€ n β€ 2Β·105) β then number of notes in Petya's logbook.
The second line contains n non-negative integers t1, t2, ..., tn (0 β€ ti < i) β notes in the logbook.
Output
In the only line print a single integer β the minimum possible number of rooms in Paris catacombs.
Examples
Input
2
0 0
Output
2
Input
5
0 1 0 1 3
Output
3
Note
In the first sample, sequence of rooms Petya visited could be, for example 1 β 1 β 2, 1 β 2 β 1 or 1 β 2 β 3. The minimum possible number of rooms is 2.
In the second sample, the sequence could be 1 β 2 β 3 β 1 β 2 β 1.
Submitted Solution:
```
x=list(map(int,input().split()))
print(len(x)+1-len(set(x)))
``` | instruction | 0 | 16,527 | 8 | 33,054 |
No | output | 1 | 16,527 | 8 | 33,055 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A very brave explorer Petya once decided to explore Paris catacombs. Since Petya is not really experienced, his exploration is just walking through the catacombs.
Catacombs consist of several rooms and bidirectional passages between some pairs of them. Some passages can connect a room to itself and since the passages are built on different depths they do not intersect each other. Every minute Petya arbitrary chooses a passage from the room he is currently in and then reaches the room on the other end of the passage in exactly one minute. When he enters a room at minute i, he makes a note in his logbook with number ti:
* If Petya has visited this room before, he writes down the minute he was in this room last time;
* Otherwise, Petya writes down an arbitrary non-negative integer strictly less than current minute i.
Initially, Petya was in one of the rooms at minute 0, he didn't write down number t0.
At some point during his wandering Petya got tired, threw out his logbook and went home. Vasya found his logbook and now he is curious: what is the minimum possible number of rooms in Paris catacombs according to Petya's logbook?
Input
The first line contains a single integer n (1 β€ n β€ 2Β·105) β then number of notes in Petya's logbook.
The second line contains n non-negative integers t1, t2, ..., tn (0 β€ ti < i) β notes in the logbook.
Output
In the only line print a single integer β the minimum possible number of rooms in Paris catacombs.
Examples
Input
2
0 0
Output
2
Input
5
0 1 0 1 3
Output
3
Note
In the first sample, sequence of rooms Petya visited could be, for example 1 β 1 β 2, 1 β 2 β 1 or 1 β 2 β 3. The minimum possible number of rooms is 2.
In the second sample, the sequence could be 1 β 2 β 3 β 1 β 2 β 1.
Submitted Solution:
```
n = int(input())
a = [int(x) for x in input().split()]
q = set(a)
k = len(q)
r = len(a)
if(r==1):
print(2)
elif( r==2):
print(2)
else:
sum1 = 0
for i in q:
if a.count(i)==2 or a.count(i)==1:
sum1+=1
print(sum1)
``` | instruction | 0 | 16,528 | 8 | 33,056 |
No | output | 1 | 16,528 | 8 | 33,057 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A very brave explorer Petya once decided to explore Paris catacombs. Since Petya is not really experienced, his exploration is just walking through the catacombs.
Catacombs consist of several rooms and bidirectional passages between some pairs of them. Some passages can connect a room to itself and since the passages are built on different depths they do not intersect each other. Every minute Petya arbitrary chooses a passage from the room he is currently in and then reaches the room on the other end of the passage in exactly one minute. When he enters a room at minute i, he makes a note in his logbook with number ti:
* If Petya has visited this room before, he writes down the minute he was in this room last time;
* Otherwise, Petya writes down an arbitrary non-negative integer strictly less than current minute i.
Initially, Petya was in one of the rooms at minute 0, he didn't write down number t0.
At some point during his wandering Petya got tired, threw out his logbook and went home. Vasya found his logbook and now he is curious: what is the minimum possible number of rooms in Paris catacombs according to Petya's logbook?
Input
The first line contains a single integer n (1 β€ n β€ 2Β·105) β then number of notes in Petya's logbook.
The second line contains n non-negative integers t1, t2, ..., tn (0 β€ ti < i) β notes in the logbook.
Output
In the only line print a single integer β the minimum possible number of rooms in Paris catacombs.
Examples
Input
2
0 0
Output
2
Input
5
0 1 0 1 3
Output
3
Note
In the first sample, sequence of rooms Petya visited could be, for example 1 β 1 β 2, 1 β 2 β 1 or 1 β 2 β 3. The minimum possible number of rooms is 2.
In the second sample, the sequence could be 1 β 2 β 3 β 1 β 2 β 1.
Submitted Solution:
```
n=int(input())
a=list(map(int,input().split()))
ans={a[0]}
last=a[0]
k=0
for i in a[1:]:
if i==last:
k+=1
ans.add(i)
last=i
print(len(ans)+k)
``` | instruction | 0 | 16,529 | 8 | 33,058 |
No | output | 1 | 16,529 | 8 | 33,059 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A very brave explorer Petya once decided to explore Paris catacombs. Since Petya is not really experienced, his exploration is just walking through the catacombs.
Catacombs consist of several rooms and bidirectional passages between some pairs of them. Some passages can connect a room to itself and since the passages are built on different depths they do not intersect each other. Every minute Petya arbitrary chooses a passage from the room he is currently in and then reaches the room on the other end of the passage in exactly one minute. When he enters a room at minute i, he makes a note in his logbook with number ti:
* If Petya has visited this room before, he writes down the minute he was in this room last time;
* Otherwise, Petya writes down an arbitrary non-negative integer strictly less than current minute i.
Initially, Petya was in one of the rooms at minute 0, he didn't write down number t0.
At some point during his wandering Petya got tired, threw out his logbook and went home. Vasya found his logbook and now he is curious: what is the minimum possible number of rooms in Paris catacombs according to Petya's logbook?
Input
The first line contains a single integer n (1 β€ n β€ 2Β·105) β then number of notes in Petya's logbook.
The second line contains n non-negative integers t1, t2, ..., tn (0 β€ ti < i) β notes in the logbook.
Output
In the only line print a single integer β the minimum possible number of rooms in Paris catacombs.
Examples
Input
2
0 0
Output
2
Input
5
0 1 0 1 3
Output
3
Note
In the first sample, sequence of rooms Petya visited could be, for example 1 β 1 β 2, 1 β 2 β 1 or 1 β 2 β 3. The minimum possible number of rooms is 2.
In the second sample, the sequence could be 1 β 2 β 3 β 1 β 2 β 1.
Submitted Solution:
```
n = int(input())
m = list(map(int, input().split(" ")))
c = []
for i in range(1, n):
if m[i] not in c:
c.append(m[i])
if m[1] == 0:
c.append(m[i])
print(len(c))
``` | instruction | 0 | 16,530 | 8 | 33,060 |
No | output | 1 | 16,530 | 8 | 33,061 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the house where Krosh used to live, he had n cupboards standing in a line, the i-th cupboard had the height of h_i. Krosh moved recently, but he wasn't able to move the cupboards with him. Now he wants to buy n new cupboards so that they look as similar to old ones as possible.
Krosh does not remember the exact heights of the cupboards, but for every three consecutive cupboards he remembers the height difference between the tallest and the shortest of them. In other words, if the cupboards' heights were h_1, h_2, β¦, h_n, then Krosh remembers the values w_i = max(h_{i}, h_{i + 1}, h_{i + 2}) - min(h_{i}, h_{i + 1}, h_{i + 2}) for all 1 β€ i β€ n - 2.
Krosh wants to buy such n cupboards that all the values w_i remain the same. Help him determine the required cupboards' heights, or determine that he remembers something incorrectly and there is no suitable sequence of heights.
Input
The first line contains two integers n and C (3 β€ n β€ 10^6, 0 β€ C β€ 10^{12}) β the number of cupboards and the limit on possible w_i.
The second line contains n - 2 integers w_1, w_2, β¦, w_{n - 2} (0 β€ w_i β€ C) β the values defined in the statement.
Output
If there is no suitable sequence of n cupboards, print "NO".
Otherwise print "YES" in the first line, then in the second line print n integers h'_1, h'_2, β¦, h'_n (0 β€ h'_i β€ 10^{18}) β the heights of the cupboards to buy, from left to right.
We can show that if there is a solution, there is also a solution satisfying the constraints on heights.
If there are multiple answers, print any.
Examples
Input
7 20
4 8 12 16 20
Output
YES
4 8 8 16 20 4 0
Input
11 10
5 7 2 3 4 5 2 1 8
Output
YES
1 1 6 8 6 5 2 0 0 1 8
Input
6 9
1 6 9 0
Output
NO
Note
Consider the first example:
* w_1 = max(4, 8, 8) - min(4, 8, 8) = 8 - 4 = 4
* w_2 = max(8, 8, 16) - min(8, 8, 16) = 16 - 8 = 8
* w_3 = max(8, 16, 20) - min(8, 16, 20) = 20 - 8 = 12
* w_4 = max(16, 20, 4) - min(16, 20, 4) = 20 - 4 = 16
* w_5 = max(20, 4, 0) - min(20, 4, 0) = 20 - 0 = 20
There are other possible solutions, for example, the following: 0, 1, 4, 9, 16, 25, 36.
Submitted Solution:
```
n,l=map(int,input().split())
arr=list(map(int,input().split()))
ans=[0,0]
def helper(ind, prev, p_prev):
if ind==n-2:
return []
a=max(prev, p_prev)-arr[ind]
if a>=0 and a<=min(prev, p_prev):
x=helper(ind+1, a, prev)
if len(x)==n-ind-3:
return [a]+x
b=min(prev, p_prev)+arr[ind]
if b<=l and b>=max(prev, p_prev):
x=helper(ind+1, b, prev)
if len(x)==n-ind-3:
return [b]+x
return []
x=helper(0, 0, 0)
if len(x)==0:
print("NO")
else:
print("YES")
print([0,0]+x)
``` | instruction | 0 | 17,026 | 8 | 34,052 |
No | output | 1 | 17,026 | 8 | 34,053 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the house where Krosh used to live, he had n cupboards standing in a line, the i-th cupboard had the height of h_i. Krosh moved recently, but he wasn't able to move the cupboards with him. Now he wants to buy n new cupboards so that they look as similar to old ones as possible.
Krosh does not remember the exact heights of the cupboards, but for every three consecutive cupboards he remembers the height difference between the tallest and the shortest of them. In other words, if the cupboards' heights were h_1, h_2, β¦, h_n, then Krosh remembers the values w_i = max(h_{i}, h_{i + 1}, h_{i + 2}) - min(h_{i}, h_{i + 1}, h_{i + 2}) for all 1 β€ i β€ n - 2.
Krosh wants to buy such n cupboards that all the values w_i remain the same. Help him determine the required cupboards' heights, or determine that he remembers something incorrectly and there is no suitable sequence of heights.
Input
The first line contains two integers n and C (3 β€ n β€ 10^6, 0 β€ C β€ 10^{12}) β the number of cupboards and the limit on possible w_i.
The second line contains n - 2 integers w_1, w_2, β¦, w_{n - 2} (0 β€ w_i β€ C) β the values defined in the statement.
Output
If there is no suitable sequence of n cupboards, print "NO".
Otherwise print "YES" in the first line, then in the second line print n integers h'_1, h'_2, β¦, h'_n (0 β€ h'_i β€ 10^{18}) β the heights of the cupboards to buy, from left to right.
We can show that if there is a solution, there is also a solution satisfying the constraints on heights.
If there are multiple answers, print any.
Examples
Input
7 20
4 8 12 16 20
Output
YES
4 8 8 16 20 4 0
Input
11 10
5 7 2 3 4 5 2 1 8
Output
YES
1 1 6 8 6 5 2 0 0 1 8
Input
6 9
1 6 9 0
Output
NO
Note
Consider the first example:
* w_1 = max(4, 8, 8) - min(4, 8, 8) = 8 - 4 = 4
* w_2 = max(8, 8, 16) - min(8, 8, 16) = 16 - 8 = 8
* w_3 = max(8, 16, 20) - min(8, 16, 20) = 20 - 8 = 12
* w_4 = max(16, 20, 4) - min(16, 20, 4) = 20 - 4 = 16
* w_5 = max(20, 4, 0) - min(20, 4, 0) = 20 - 0 = 20
There are other possible solutions, for example, the following: 0, 1, 4, 9, 16, 25, 36.
Submitted Solution:
```
n,l=map(int,input().split())
arr=list(map(int,input().split()))
ans=[0,0]
def helper(ind, prev, p_prev):
if ind==n-2:
return []
a=max(prev, p_prev)-arr[ind]
if a>=0 and a<=min(prev, p_prev):
x=helper(ind+1, a, prev)
if len(x)==n-ind-3:
return [a]+x
b=min(prev, p_prev)+arr[ind]
if b<=l and b>=max(prev, p_prev):
x=helper(ind+1, b, prev)
if len(x)==n-ind-3:
return [b]+x
return []
x=helper(0, 0, 0)
if len(x)==0:
print("NO")
else:
print("YES")
x=[0,0]+x
print(*x)
``` | instruction | 0 | 17,027 | 8 | 34,054 |
No | output | 1 | 17,027 | 8 | 34,055 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the house where Krosh used to live, he had n cupboards standing in a line, the i-th cupboard had the height of h_i. Krosh moved recently, but he wasn't able to move the cupboards with him. Now he wants to buy n new cupboards so that they look as similar to old ones as possible.
Krosh does not remember the exact heights of the cupboards, but for every three consecutive cupboards he remembers the height difference between the tallest and the shortest of them. In other words, if the cupboards' heights were h_1, h_2, β¦, h_n, then Krosh remembers the values w_i = max(h_{i}, h_{i + 1}, h_{i + 2}) - min(h_{i}, h_{i + 1}, h_{i + 2}) for all 1 β€ i β€ n - 2.
Krosh wants to buy such n cupboards that all the values w_i remain the same. Help him determine the required cupboards' heights, or determine that he remembers something incorrectly and there is no suitable sequence of heights.
Input
The first line contains two integers n and C (3 β€ n β€ 10^6, 0 β€ C β€ 10^{12}) β the number of cupboards and the limit on possible w_i.
The second line contains n - 2 integers w_1, w_2, β¦, w_{n - 2} (0 β€ w_i β€ C) β the values defined in the statement.
Output
If there is no suitable sequence of n cupboards, print "NO".
Otherwise print "YES" in the first line, then in the second line print n integers h'_1, h'_2, β¦, h'_n (0 β€ h'_i β€ 10^{18}) β the heights of the cupboards to buy, from left to right.
We can show that if there is a solution, there is also a solution satisfying the constraints on heights.
If there are multiple answers, print any.
Examples
Input
7 20
4 8 12 16 20
Output
YES
4 8 8 16 20 4 0
Input
11 10
5 7 2 3 4 5 2 1 8
Output
YES
1 1 6 8 6 5 2 0 0 1 8
Input
6 9
1 6 9 0
Output
NO
Note
Consider the first example:
* w_1 = max(4, 8, 8) - min(4, 8, 8) = 8 - 4 = 4
* w_2 = max(8, 8, 16) - min(8, 8, 16) = 16 - 8 = 8
* w_3 = max(8, 16, 20) - min(8, 16, 20) = 20 - 8 = 12
* w_4 = max(16, 20, 4) - min(16, 20, 4) = 20 - 4 = 16
* w_5 = max(20, 4, 0) - min(20, 4, 0) = 20 - 0 = 20
There are other possible solutions, for example, the following: 0, 1, 4, 9, 16, 25, 36.
Submitted Solution:
```
import sys
# def pripitka(massivl,lowers):
# pr = []
# pr = ['0' for i in range(0,lowers)]
# edgel = lowers+1
#
# for i in range(lowers,0,-1):
# koll = massivl[i-1]
# end = i-koll+1
# if end<=0:
# end = 1
# for j in range(edgel-1,end-1,-1):
# pr[j-1] = '1'
# edgel = j
# if i<edgel:
# edgel = i
# stdout_fileno = sys.stdout
# if num>1:
# stdout_fileno.write('\n')
# stdout_fileno.write(' '.join(pr))
#f = open('D:\input.txt', 'r')
f = sys.stdin
fline = f.readline()
s = [int(i) for i in fline.split()]
kols = s[0]
sline = f.readline()
w = [int(i) for i in sline.split()]
pr = []
pr = [0 for i in range(0,kols)]
stdout_fileno = sys.stdout
n=0
res = 'YES'
for i in w:
if n==0:
pr[n+2] = i
pr[n+1] = i
maxpred = pr[n+2]
minpred = pr[n+1]
n+=1
elif i<=minpred:
if i==0 and pr[n]!=pr[n+1]:
res = 'NO'
break
pr[n+2] = minpred-i
minpred = pr[n+2]
n+=1
elif i<=maxpred:
pr[n+2] = maxpred-i
minpred = pr[n+2]
n+=1
else:
pr[n+2] = minpred+i
minpred = min(pr[n+1],pr[n])
minpred = max(pr[n+1],pr[n])
n+=1
if res == 'NO':
stdout_fileno.write('NO')
else:
stdout_fileno.write('YES')
stdout_fileno.write('\n')
fs = True
for i in pr:
if fs:
stdout_fileno.write(str(i))
fs = False
else:
stdout_fileno.write(' ' + str(i))
f.close()
``` | instruction | 0 | 17,028 | 8 | 34,056 |
No | output | 1 | 17,028 | 8 | 34,057 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the house where Krosh used to live, he had n cupboards standing in a line, the i-th cupboard had the height of h_i. Krosh moved recently, but he wasn't able to move the cupboards with him. Now he wants to buy n new cupboards so that they look as similar to old ones as possible.
Krosh does not remember the exact heights of the cupboards, but for every three consecutive cupboards he remembers the height difference between the tallest and the shortest of them. In other words, if the cupboards' heights were h_1, h_2, β¦, h_n, then Krosh remembers the values w_i = max(h_{i}, h_{i + 1}, h_{i + 2}) - min(h_{i}, h_{i + 1}, h_{i + 2}) for all 1 β€ i β€ n - 2.
Krosh wants to buy such n cupboards that all the values w_i remain the same. Help him determine the required cupboards' heights, or determine that he remembers something incorrectly and there is no suitable sequence of heights.
Input
The first line contains two integers n and C (3 β€ n β€ 10^6, 0 β€ C β€ 10^{12}) β the number of cupboards and the limit on possible w_i.
The second line contains n - 2 integers w_1, w_2, β¦, w_{n - 2} (0 β€ w_i β€ C) β the values defined in the statement.
Output
If there is no suitable sequence of n cupboards, print "NO".
Otherwise print "YES" in the first line, then in the second line print n integers h'_1, h'_2, β¦, h'_n (0 β€ h'_i β€ 10^{18}) β the heights of the cupboards to buy, from left to right.
We can show that if there is a solution, there is also a solution satisfying the constraints on heights.
If there are multiple answers, print any.
Examples
Input
7 20
4 8 12 16 20
Output
YES
4 8 8 16 20 4 0
Input
11 10
5 7 2 3 4 5 2 1 8
Output
YES
1 1 6 8 6 5 2 0 0 1 8
Input
6 9
1 6 9 0
Output
NO
Note
Consider the first example:
* w_1 = max(4, 8, 8) - min(4, 8, 8) = 8 - 4 = 4
* w_2 = max(8, 8, 16) - min(8, 8, 16) = 16 - 8 = 8
* w_3 = max(8, 16, 20) - min(8, 16, 20) = 20 - 8 = 12
* w_4 = max(16, 20, 4) - min(16, 20, 4) = 20 - 4 = 16
* w_5 = max(20, 4, 0) - min(20, 4, 0) = 20 - 0 = 20
There are other possible solutions, for example, the following: 0, 1, 4, 9, 16, 25, 36.
Submitted Solution:
```
import sys
# def pripitka(massivl,lowers):
# pr = []
# pr = ['0' for i in range(0,lowers)]
# edgel = lowers+1
#
# for i in range(lowers,0,-1):
# koll = massivl[i-1]
# end = i-koll+1
# if end<=0:
# end = 1
# for j in range(edgel-1,end-1,-1):
# pr[j-1] = '1'
# edgel = j
# if i<edgel:
# edgel = i
# stdout_fileno = sys.stdout
# if num>1:
# stdout_fileno.write('\n')
# stdout_fileno.write(' '.join(pr))
#f = open('D:\input.txt', 'r')
f = sys.stdin
fline = f.readline()
s = [int(i) for i in fline.split()]
kols = s[0]
sline = f.readline()
w = [int(i) for i in sline.split()]
pr = []
pr = [0 for i in range(0,kols)]
stdout_fileno = sys.stdout
n=0
res = 'YES'
for i in w:
if n==0:
pr[n+2] = i
pr[n+1] = i
maxpred = pr[n+2]
minpred = pr[n+1]
n+=1
elif i<=minpred:
if i==0 and pr[n]!=pr[n+1]:
res = 'NO'
break
pr[n+2] = minpred-i
minpred = pr[n+2]
n+=1
elif i<=maxpred:
pr[n+2] = maxpred-i
minpred = pr[n+2]
n+=1
else:
pr[n+2] = maxpred+i
minpred = maxpred
maxpred = pr[n+2]
n+=1
if res == 'NO':
stdout_fileno.write('NO')
else:
stdout_fileno.write('YES')
stdout_fileno.write('\n')
fs = True
for i in pr:
if fs:
stdout_fileno.write(str(i))
fs = False
else:
stdout_fileno.write(' ' + str(i))
f.close()
``` | instruction | 0 | 17,029 | 8 | 34,058 |
No | output | 1 | 17,029 | 8 | 34,059 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Dima's got a staircase that consists of n stairs. The first stair is at height a1, the second one is at a2, the last one is at an (1 β€ a1 β€ a2 β€ ... β€ an).
Dima decided to play with the staircase, so he is throwing rectangular boxes at the staircase from above. The i-th box has width wi and height hi. Dima throws each box vertically down on the first wi stairs of the staircase, that is, the box covers stairs with numbers 1, 2, ..., wi. Each thrown box flies vertically down until at least one of the two following events happen:
* the bottom of the box touches the top of a stair;
* the bottom of the box touches the top of a box, thrown earlier.
We only consider touching of the horizontal sides of stairs and boxes, at that touching with the corners isn't taken into consideration. Specifically, that implies that a box with width wi cannot touch the stair number wi + 1.
You are given the description of the staircase and the sequence in which Dima threw the boxes at it. For each box, determine how high the bottom of the box after landing will be. Consider a box to fall after the previous one lands.
Input
The first line contains integer n (1 β€ n β€ 105) β the number of stairs in the staircase. The second line contains a non-decreasing sequence, consisting of n integers, a1, a2, ..., an (1 β€ ai β€ 109; ai β€ ai + 1).
The next line contains integer m (1 β€ m β€ 105) β the number of boxes. Each of the following m lines contains a pair of integers wi, hi (1 β€ wi β€ n; 1 β€ hi β€ 109) β the size of the i-th thrown box.
The numbers in the lines are separated by spaces.
Output
Print m integers β for each box the height, where the bottom of the box will be after landing. Print the answers for the boxes in the order, in which the boxes are given in the input.
Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
5
1 2 3 6 6
4
1 1
3 1
1 1
4 3
Output
1
3
4
6
Input
3
1 2 3
2
1 1
3 1
Output
1
3
Input
1
1
5
1 2
1 10
1 10
1 10
1 10
Output
1
3
13
23
33
Note
The first sample are shown on the picture.
<image> | instruction | 0 | 17,079 | 8 | 34,158 |
Tags: data structures, implementation
Correct Solution:
```
n = int(input())
a = list(map(int,input().split()))
m = int(input())
l = [list(map(int,input().split())) for _ in range(m)]
ans = [a[l[0][0]-1]]
lasth = l[0][1]
for _,[w,h] in enumerate(l[1:]):
ans.append(max(ans[-1] + lasth,a[w-1]))
lasth = h
print(*ans,sep='\n')
``` | output | 1 | 17,079 | 8 | 34,159 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Dima's got a staircase that consists of n stairs. The first stair is at height a1, the second one is at a2, the last one is at an (1 β€ a1 β€ a2 β€ ... β€ an).
Dima decided to play with the staircase, so he is throwing rectangular boxes at the staircase from above. The i-th box has width wi and height hi. Dima throws each box vertically down on the first wi stairs of the staircase, that is, the box covers stairs with numbers 1, 2, ..., wi. Each thrown box flies vertically down until at least one of the two following events happen:
* the bottom of the box touches the top of a stair;
* the bottom of the box touches the top of a box, thrown earlier.
We only consider touching of the horizontal sides of stairs and boxes, at that touching with the corners isn't taken into consideration. Specifically, that implies that a box with width wi cannot touch the stair number wi + 1.
You are given the description of the staircase and the sequence in which Dima threw the boxes at it. For each box, determine how high the bottom of the box after landing will be. Consider a box to fall after the previous one lands.
Input
The first line contains integer n (1 β€ n β€ 105) β the number of stairs in the staircase. The second line contains a non-decreasing sequence, consisting of n integers, a1, a2, ..., an (1 β€ ai β€ 109; ai β€ ai + 1).
The next line contains integer m (1 β€ m β€ 105) β the number of boxes. Each of the following m lines contains a pair of integers wi, hi (1 β€ wi β€ n; 1 β€ hi β€ 109) β the size of the i-th thrown box.
The numbers in the lines are separated by spaces.
Output
Print m integers β for each box the height, where the bottom of the box will be after landing. Print the answers for the boxes in the order, in which the boxes are given in the input.
Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
5
1 2 3 6 6
4
1 1
3 1
1 1
4 3
Output
1
3
4
6
Input
3
1 2 3
2
1 1
3 1
Output
1
3
Input
1
1
5
1 2
1 10
1 10
1 10
1 10
Output
1
3
13
23
33
Note
The first sample are shown on the picture.
<image> | instruction | 0 | 17,080 | 8 | 34,160 |
Tags: data structures, implementation
Correct Solution:
```
from sys import stdin
rdi = lambda: list(map(int, stdin.readline().split()))
rdi()
a = rdi()
for _ in range(rdi()[0]):
w, h = rdi()
m = max(a[0], a[w-1])
a[0] = m+h
print(m)
``` | output | 1 | 17,080 | 8 | 34,161 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Dima's got a staircase that consists of n stairs. The first stair is at height a1, the second one is at a2, the last one is at an (1 β€ a1 β€ a2 β€ ... β€ an).
Dima decided to play with the staircase, so he is throwing rectangular boxes at the staircase from above. The i-th box has width wi and height hi. Dima throws each box vertically down on the first wi stairs of the staircase, that is, the box covers stairs with numbers 1, 2, ..., wi. Each thrown box flies vertically down until at least one of the two following events happen:
* the bottom of the box touches the top of a stair;
* the bottom of the box touches the top of a box, thrown earlier.
We only consider touching of the horizontal sides of stairs and boxes, at that touching with the corners isn't taken into consideration. Specifically, that implies that a box with width wi cannot touch the stair number wi + 1.
You are given the description of the staircase and the sequence in which Dima threw the boxes at it. For each box, determine how high the bottom of the box after landing will be. Consider a box to fall after the previous one lands.
Input
The first line contains integer n (1 β€ n β€ 105) β the number of stairs in the staircase. The second line contains a non-decreasing sequence, consisting of n integers, a1, a2, ..., an (1 β€ ai β€ 109; ai β€ ai + 1).
The next line contains integer m (1 β€ m β€ 105) β the number of boxes. Each of the following m lines contains a pair of integers wi, hi (1 β€ wi β€ n; 1 β€ hi β€ 109) β the size of the i-th thrown box.
The numbers in the lines are separated by spaces.
Output
Print m integers β for each box the height, where the bottom of the box will be after landing. Print the answers for the boxes in the order, in which the boxes are given in the input.
Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
5
1 2 3 6 6
4
1 1
3 1
1 1
4 3
Output
1
3
4
6
Input
3
1 2 3
2
1 1
3 1
Output
1
3
Input
1
1
5
1 2
1 10
1 10
1 10
1 10
Output
1
3
13
23
33
Note
The first sample are shown on the picture.
<image> | instruction | 0 | 17,081 | 8 | 34,162 |
Tags: data structures, implementation
Correct Solution:
```
n = input()
stairs = list(map(int,input().split(' ')))
boxes = []
for i in range(int(input())):
boxes.append(list(map(int,input().split(' '))))
ch = stairs[0]
ans = []
for box in boxes:
nh = max(ch,stairs[box[0]-1])
ans.append(nh)
ch = nh + box[1]
print(*ans,sep = '\n')
``` | output | 1 | 17,081 | 8 | 34,163 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Dima's got a staircase that consists of n stairs. The first stair is at height a1, the second one is at a2, the last one is at an (1 β€ a1 β€ a2 β€ ... β€ an).
Dima decided to play with the staircase, so he is throwing rectangular boxes at the staircase from above. The i-th box has width wi and height hi. Dima throws each box vertically down on the first wi stairs of the staircase, that is, the box covers stairs with numbers 1, 2, ..., wi. Each thrown box flies vertically down until at least one of the two following events happen:
* the bottom of the box touches the top of a stair;
* the bottom of the box touches the top of a box, thrown earlier.
We only consider touching of the horizontal sides of stairs and boxes, at that touching with the corners isn't taken into consideration. Specifically, that implies that a box with width wi cannot touch the stair number wi + 1.
You are given the description of the staircase and the sequence in which Dima threw the boxes at it. For each box, determine how high the bottom of the box after landing will be. Consider a box to fall after the previous one lands.
Input
The first line contains integer n (1 β€ n β€ 105) β the number of stairs in the staircase. The second line contains a non-decreasing sequence, consisting of n integers, a1, a2, ..., an (1 β€ ai β€ 109; ai β€ ai + 1).
The next line contains integer m (1 β€ m β€ 105) β the number of boxes. Each of the following m lines contains a pair of integers wi, hi (1 β€ wi β€ n; 1 β€ hi β€ 109) β the size of the i-th thrown box.
The numbers in the lines are separated by spaces.
Output
Print m integers β for each box the height, where the bottom of the box will be after landing. Print the answers for the boxes in the order, in which the boxes are given in the input.
Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
5
1 2 3 6 6
4
1 1
3 1
1 1
4 3
Output
1
3
4
6
Input
3
1 2 3
2
1 1
3 1
Output
1
3
Input
1
1
5
1 2
1 10
1 10
1 10
1 10
Output
1
3
13
23
33
Note
The first sample are shown on the picture.
<image> | instruction | 0 | 17,082 | 8 | 34,164 |
Tags: data structures, implementation
Correct Solution:
```
n = int(input())
import sys
l = [0]+list(map(int,sys.stdin.readline().strip().split()))
x = 0
b = 0
m = int(input())
for _ in range(m):
w,h = map(int,sys.stdin.readline().strip().split())
x = max(x+b,l[w])
b = h
print(x)
``` | output | 1 | 17,082 | 8 | 34,165 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Dima's got a staircase that consists of n stairs. The first stair is at height a1, the second one is at a2, the last one is at an (1 β€ a1 β€ a2 β€ ... β€ an).
Dima decided to play with the staircase, so he is throwing rectangular boxes at the staircase from above. The i-th box has width wi and height hi. Dima throws each box vertically down on the first wi stairs of the staircase, that is, the box covers stairs with numbers 1, 2, ..., wi. Each thrown box flies vertically down until at least one of the two following events happen:
* the bottom of the box touches the top of a stair;
* the bottom of the box touches the top of a box, thrown earlier.
We only consider touching of the horizontal sides of stairs and boxes, at that touching with the corners isn't taken into consideration. Specifically, that implies that a box with width wi cannot touch the stair number wi + 1.
You are given the description of the staircase and the sequence in which Dima threw the boxes at it. For each box, determine how high the bottom of the box after landing will be. Consider a box to fall after the previous one lands.
Input
The first line contains integer n (1 β€ n β€ 105) β the number of stairs in the staircase. The second line contains a non-decreasing sequence, consisting of n integers, a1, a2, ..., an (1 β€ ai β€ 109; ai β€ ai + 1).
The next line contains integer m (1 β€ m β€ 105) β the number of boxes. Each of the following m lines contains a pair of integers wi, hi (1 β€ wi β€ n; 1 β€ hi β€ 109) β the size of the i-th thrown box.
The numbers in the lines are separated by spaces.
Output
Print m integers β for each box the height, where the bottom of the box will be after landing. Print the answers for the boxes in the order, in which the boxes are given in the input.
Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
5
1 2 3 6 6
4
1 1
3 1
1 1
4 3
Output
1
3
4
6
Input
3
1 2 3
2
1 1
3 1
Output
1
3
Input
1
1
5
1 2
1 10
1 10
1 10
1 10
Output
1
3
13
23
33
Note
The first sample are shown on the picture.
<image> | instruction | 0 | 17,083 | 8 | 34,166 |
Tags: data structures, implementation
Correct Solution:
```
n=int(input())
l=list(map(int,input().split()))
m=int(input())
s=[]
for i in range(m):
s+=[list(map(int,input().split()))]
h=[]
a=0
for i in range(m):
b=l[s[i][0]-1]
t=max(b,a+1)
h+=[t]
a=t+s[i][1]-1
for i in h:
print(i)
``` | output | 1 | 17,083 | 8 | 34,167 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Dima's got a staircase that consists of n stairs. The first stair is at height a1, the second one is at a2, the last one is at an (1 β€ a1 β€ a2 β€ ... β€ an).
Dima decided to play with the staircase, so he is throwing rectangular boxes at the staircase from above. The i-th box has width wi and height hi. Dima throws each box vertically down on the first wi stairs of the staircase, that is, the box covers stairs with numbers 1, 2, ..., wi. Each thrown box flies vertically down until at least one of the two following events happen:
* the bottom of the box touches the top of a stair;
* the bottom of the box touches the top of a box, thrown earlier.
We only consider touching of the horizontal sides of stairs and boxes, at that touching with the corners isn't taken into consideration. Specifically, that implies that a box with width wi cannot touch the stair number wi + 1.
You are given the description of the staircase and the sequence in which Dima threw the boxes at it. For each box, determine how high the bottom of the box after landing will be. Consider a box to fall after the previous one lands.
Input
The first line contains integer n (1 β€ n β€ 105) β the number of stairs in the staircase. The second line contains a non-decreasing sequence, consisting of n integers, a1, a2, ..., an (1 β€ ai β€ 109; ai β€ ai + 1).
The next line contains integer m (1 β€ m β€ 105) β the number of boxes. Each of the following m lines contains a pair of integers wi, hi (1 β€ wi β€ n; 1 β€ hi β€ 109) β the size of the i-th thrown box.
The numbers in the lines are separated by spaces.
Output
Print m integers β for each box the height, where the bottom of the box will be after landing. Print the answers for the boxes in the order, in which the boxes are given in the input.
Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
5
1 2 3 6 6
4
1 1
3 1
1 1
4 3
Output
1
3
4
6
Input
3
1 2 3
2
1 1
3 1
Output
1
3
Input
1
1
5
1 2
1 10
1 10
1 10
1 10
Output
1
3
13
23
33
Note
The first sample are shown on the picture.
<image> | instruction | 0 | 17,084 | 8 | 34,168 |
Tags: data structures, implementation
Correct Solution:
```
n = int(input())
a = list(map(int, input().split()))
m = int(input())
b = {}
t = []
for i in range(m):
w, h = list(map(int, input().split()))
x = max(a[0],a[w-1])
t.append(x)
a[0] = x+h
a[w-1] = x+h
for i in range(m):
print(t[i])
``` | output | 1 | 17,084 | 8 | 34,169 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Dima's got a staircase that consists of n stairs. The first stair is at height a1, the second one is at a2, the last one is at an (1 β€ a1 β€ a2 β€ ... β€ an).
Dima decided to play with the staircase, so he is throwing rectangular boxes at the staircase from above. The i-th box has width wi and height hi. Dima throws each box vertically down on the first wi stairs of the staircase, that is, the box covers stairs with numbers 1, 2, ..., wi. Each thrown box flies vertically down until at least one of the two following events happen:
* the bottom of the box touches the top of a stair;
* the bottom of the box touches the top of a box, thrown earlier.
We only consider touching of the horizontal sides of stairs and boxes, at that touching with the corners isn't taken into consideration. Specifically, that implies that a box with width wi cannot touch the stair number wi + 1.
You are given the description of the staircase and the sequence in which Dima threw the boxes at it. For each box, determine how high the bottom of the box after landing will be. Consider a box to fall after the previous one lands.
Input
The first line contains integer n (1 β€ n β€ 105) β the number of stairs in the staircase. The second line contains a non-decreasing sequence, consisting of n integers, a1, a2, ..., an (1 β€ ai β€ 109; ai β€ ai + 1).
The next line contains integer m (1 β€ m β€ 105) β the number of boxes. Each of the following m lines contains a pair of integers wi, hi (1 β€ wi β€ n; 1 β€ hi β€ 109) β the size of the i-th thrown box.
The numbers in the lines are separated by spaces.
Output
Print m integers β for each box the height, where the bottom of the box will be after landing. Print the answers for the boxes in the order, in which the boxes are given in the input.
Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
5
1 2 3 6 6
4
1 1
3 1
1 1
4 3
Output
1
3
4
6
Input
3
1 2 3
2
1 1
3 1
Output
1
3
Input
1
1
5
1 2
1 10
1 10
1 10
1 10
Output
1
3
13
23
33
Note
The first sample are shown on the picture.
<image> | instruction | 0 | 17,085 | 8 | 34,170 |
Tags: data structures, implementation
Correct Solution:
```
#pyrival orz
import os
import sys
from io import BytesIO, IOBase
input = sys.stdin.readline
############ ---- Input Functions ---- ############
def inp():
return(int(input()))
def inlt():
return(list(map(int,input().split())))
def insr():
s = input()
return(list(s[:len(s) - 1]))
def invr():
return(map(int,input().split()))
def gcd(a, b):
if b == 0:
return a
else:
return gcd(b, a%b)
def seive(n):
primes = [True]*(n+1)
for i in range(2, n):
if not primes[i]:
continue
j = 2*i
while j <= n:
primes[j] = False
j += i
return primes
def factors(n):
factors = []
x = 2
while x*x <= n:
while n % x == 0:
factors.append(x)
n //= x
if n > 1:
factors.append(x)
return factors
# Functions: list of factors, seive of primes, gcd of two numbers
def main():
try:
n = inp()
a = inlt()
m = inp()
ans = 0
for i in range(m):
w, h = invr()
value = a[w-1]
ans = max(value, ans)
print(ans)
ans += h
# for j in range(w):
# a[j] = ans + h
except Exception as e:
print(e)
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# endregion
if __name__ == "__main__":
main()
``` | output | 1 | 17,085 | 8 | 34,171 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Dima's got a staircase that consists of n stairs. The first stair is at height a1, the second one is at a2, the last one is at an (1 β€ a1 β€ a2 β€ ... β€ an).
Dima decided to play with the staircase, so he is throwing rectangular boxes at the staircase from above. The i-th box has width wi and height hi. Dima throws each box vertically down on the first wi stairs of the staircase, that is, the box covers stairs with numbers 1, 2, ..., wi. Each thrown box flies vertically down until at least one of the two following events happen:
* the bottom of the box touches the top of a stair;
* the bottom of the box touches the top of a box, thrown earlier.
We only consider touching of the horizontal sides of stairs and boxes, at that touching with the corners isn't taken into consideration. Specifically, that implies that a box with width wi cannot touch the stair number wi + 1.
You are given the description of the staircase and the sequence in which Dima threw the boxes at it. For each box, determine how high the bottom of the box after landing will be. Consider a box to fall after the previous one lands.
Input
The first line contains integer n (1 β€ n β€ 105) β the number of stairs in the staircase. The second line contains a non-decreasing sequence, consisting of n integers, a1, a2, ..., an (1 β€ ai β€ 109; ai β€ ai + 1).
The next line contains integer m (1 β€ m β€ 105) β the number of boxes. Each of the following m lines contains a pair of integers wi, hi (1 β€ wi β€ n; 1 β€ hi β€ 109) β the size of the i-th thrown box.
The numbers in the lines are separated by spaces.
Output
Print m integers β for each box the height, where the bottom of the box will be after landing. Print the answers for the boxes in the order, in which the boxes are given in the input.
Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
5
1 2 3 6 6
4
1 1
3 1
1 1
4 3
Output
1
3
4
6
Input
3
1 2 3
2
1 1
3 1
Output
1
3
Input
1
1
5
1 2
1 10
1 10
1 10
1 10
Output
1
3
13
23
33
Note
The first sample are shown on the picture.
<image> | instruction | 0 | 17,086 | 8 | 34,172 |
Tags: data structures, implementation
Correct Solution:
```
from collections import Counter, defaultdict, OrderedDict, deque
from bisect import bisect_left, bisect_right
from functools import reduce, lru_cache
from typing import List
import itertools
import sys
import math
import heapq
import string
import random
MIN, MAX, MOD = -0x3f3f3f3f, 0x3f3f3f3f, 1000000007
def RL(): return map(int, sys.stdin.readline().rstrip().split())
def RLL(): return list(map(int, sys.stdin.readline().rstrip().split()))
def N(): return int(input())
n = N()
a = RLL()
m = N()
hit = 0
for _ in range(m):
w, h = RL()
res = max(a[w - 1], hit)
print(res)
hit = max(hit, res + h)
# mx = max(a[:w])
# print(mx)
# for i in range(w):
# a[i] = mx + h
``` | output | 1 | 17,086 | 8 | 34,173 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Dima's got a staircase that consists of n stairs. The first stair is at height a1, the second one is at a2, the last one is at an (1 β€ a1 β€ a2 β€ ... β€ an).
Dima decided to play with the staircase, so he is throwing rectangular boxes at the staircase from above. The i-th box has width wi and height hi. Dima throws each box vertically down on the first wi stairs of the staircase, that is, the box covers stairs with numbers 1, 2, ..., wi. Each thrown box flies vertically down until at least one of the two following events happen:
* the bottom of the box touches the top of a stair;
* the bottom of the box touches the top of a box, thrown earlier.
We only consider touching of the horizontal sides of stairs and boxes, at that touching with the corners isn't taken into consideration. Specifically, that implies that a box with width wi cannot touch the stair number wi + 1.
You are given the description of the staircase and the sequence in which Dima threw the boxes at it. For each box, determine how high the bottom of the box after landing will be. Consider a box to fall after the previous one lands.
Input
The first line contains integer n (1 β€ n β€ 105) β the number of stairs in the staircase. The second line contains a non-decreasing sequence, consisting of n integers, a1, a2, ..., an (1 β€ ai β€ 109; ai β€ ai + 1).
The next line contains integer m (1 β€ m β€ 105) β the number of boxes. Each of the following m lines contains a pair of integers wi, hi (1 β€ wi β€ n; 1 β€ hi β€ 109) β the size of the i-th thrown box.
The numbers in the lines are separated by spaces.
Output
Print m integers β for each box the height, where the bottom of the box will be after landing. Print the answers for the boxes in the order, in which the boxes are given in the input.
Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
5
1 2 3 6 6
4
1 1
3 1
1 1
4 3
Output
1
3
4
6
Input
3
1 2 3
2
1 1
3 1
Output
1
3
Input
1
1
5
1 2
1 10
1 10
1 10
1 10
Output
1
3
13
23
33
Note
The first sample are shown on the picture.
<image>
Submitted Solution:
```
# https://codeforces.com/problemset/problem/272/C
# we just check if the box dropped falls above the previous box or on stair number(1...w)
# the box is dropped from the top and hence we need to check the heights from the top -
# which height is suitable and higher
m = int(input())
arr = list(map(int, input().split()))
t = int(input())
for i in range(t):
w, h = map(int, input().split())
p = max(arr[0], arr[w - 1]) # checking which height is higher
print(p)
# increase the height for the next box to drop - can only drop above the
arr[0] = p + h
# current box
``` | instruction | 0 | 17,087 | 8 | 34,174 |
Yes | output | 1 | 17,087 | 8 | 34,175 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Dima's got a staircase that consists of n stairs. The first stair is at height a1, the second one is at a2, the last one is at an (1 β€ a1 β€ a2 β€ ... β€ an).
Dima decided to play with the staircase, so he is throwing rectangular boxes at the staircase from above. The i-th box has width wi and height hi. Dima throws each box vertically down on the first wi stairs of the staircase, that is, the box covers stairs with numbers 1, 2, ..., wi. Each thrown box flies vertically down until at least one of the two following events happen:
* the bottom of the box touches the top of a stair;
* the bottom of the box touches the top of a box, thrown earlier.
We only consider touching of the horizontal sides of stairs and boxes, at that touching with the corners isn't taken into consideration. Specifically, that implies that a box with width wi cannot touch the stair number wi + 1.
You are given the description of the staircase and the sequence in which Dima threw the boxes at it. For each box, determine how high the bottom of the box after landing will be. Consider a box to fall after the previous one lands.
Input
The first line contains integer n (1 β€ n β€ 105) β the number of stairs in the staircase. The second line contains a non-decreasing sequence, consisting of n integers, a1, a2, ..., an (1 β€ ai β€ 109; ai β€ ai + 1).
The next line contains integer m (1 β€ m β€ 105) β the number of boxes. Each of the following m lines contains a pair of integers wi, hi (1 β€ wi β€ n; 1 β€ hi β€ 109) β the size of the i-th thrown box.
The numbers in the lines are separated by spaces.
Output
Print m integers β for each box the height, where the bottom of the box will be after landing. Print the answers for the boxes in the order, in which the boxes are given in the input.
Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
5
1 2 3 6 6
4
1 1
3 1
1 1
4 3
Output
1
3
4
6
Input
3
1 2 3
2
1 1
3 1
Output
1
3
Input
1
1
5
1 2
1 10
1 10
1 10
1 10
Output
1
3
13
23
33
Note
The first sample are shown on the picture.
<image>
Submitted Solution:
```
# SHRi GANESHA author: Kunal Verma #
import os, sys
from bisect import bisect_left
from collections import defaultdict, Counter, deque
from copy import deepcopy
from io import BytesIO, IOBase
from math import gcd
mod = 998244353
def inv_mod(n):
return pow(n, mod - 2, mod)
def frac_mod(a, b):
return (a * inv_mod(b)) % mod
import math
import sys
def main():
n = int(input())
a = [int(x) for x in input().split()]
s = 0
for j in range(int(input())):
x, y = map(int, input().split())
print(max(s, a[x - 1]))
s = max(s, a[x - 1]) + y
# Fast IO Region
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
if __name__ == '__main__':
main()
``` | instruction | 0 | 17,088 | 8 | 34,176 |
Yes | output | 1 | 17,088 | 8 | 34,177 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Dima's got a staircase that consists of n stairs. The first stair is at height a1, the second one is at a2, the last one is at an (1 β€ a1 β€ a2 β€ ... β€ an).
Dima decided to play with the staircase, so he is throwing rectangular boxes at the staircase from above. The i-th box has width wi and height hi. Dima throws each box vertically down on the first wi stairs of the staircase, that is, the box covers stairs with numbers 1, 2, ..., wi. Each thrown box flies vertically down until at least one of the two following events happen:
* the bottom of the box touches the top of a stair;
* the bottom of the box touches the top of a box, thrown earlier.
We only consider touching of the horizontal sides of stairs and boxes, at that touching with the corners isn't taken into consideration. Specifically, that implies that a box with width wi cannot touch the stair number wi + 1.
You are given the description of the staircase and the sequence in which Dima threw the boxes at it. For each box, determine how high the bottom of the box after landing will be. Consider a box to fall after the previous one lands.
Input
The first line contains integer n (1 β€ n β€ 105) β the number of stairs in the staircase. The second line contains a non-decreasing sequence, consisting of n integers, a1, a2, ..., an (1 β€ ai β€ 109; ai β€ ai + 1).
The next line contains integer m (1 β€ m β€ 105) β the number of boxes. Each of the following m lines contains a pair of integers wi, hi (1 β€ wi β€ n; 1 β€ hi β€ 109) β the size of the i-th thrown box.
The numbers in the lines are separated by spaces.
Output
Print m integers β for each box the height, where the bottom of the box will be after landing. Print the answers for the boxes in the order, in which the boxes are given in the input.
Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
5
1 2 3 6 6
4
1 1
3 1
1 1
4 3
Output
1
3
4
6
Input
3
1 2 3
2
1 1
3 1
Output
1
3
Input
1
1
5
1 2
1 10
1 10
1 10
1 10
Output
1
3
13
23
33
Note
The first sample are shown on the picture.
<image>
Submitted Solution:
```
num_stairs = int(input())
stair_list = list(map(int, input().split()))
relative_height = 0
solutions = []
for _ in range(int(input())):
width, height = map(int, input().split())
new_height = max(stair_list[width - 1], relative_height)
solutions.append(new_height)
relative_height = new_height + height
# print("New Height: ", new_height)
# for x in range(width):
# stair_list[x] = new_height
# # print(x, stair_list[x])
# for y in range(width, len(stair_list)):
# if stair_list[y] >= new_height:
# # print(stair_list[y])
# break
# else:
# stair_list[y] = new_height
# print(stair_list[y])
print(' '.join(map(str, solutions)))
``` | instruction | 0 | 17,089 | 8 | 34,178 |
Yes | output | 1 | 17,089 | 8 | 34,179 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Dima's got a staircase that consists of n stairs. The first stair is at height a1, the second one is at a2, the last one is at an (1 β€ a1 β€ a2 β€ ... β€ an).
Dima decided to play with the staircase, so he is throwing rectangular boxes at the staircase from above. The i-th box has width wi and height hi. Dima throws each box vertically down on the first wi stairs of the staircase, that is, the box covers stairs with numbers 1, 2, ..., wi. Each thrown box flies vertically down until at least one of the two following events happen:
* the bottom of the box touches the top of a stair;
* the bottom of the box touches the top of a box, thrown earlier.
We only consider touching of the horizontal sides of stairs and boxes, at that touching with the corners isn't taken into consideration. Specifically, that implies that a box with width wi cannot touch the stair number wi + 1.
You are given the description of the staircase and the sequence in which Dima threw the boxes at it. For each box, determine how high the bottom of the box after landing will be. Consider a box to fall after the previous one lands.
Input
The first line contains integer n (1 β€ n β€ 105) β the number of stairs in the staircase. The second line contains a non-decreasing sequence, consisting of n integers, a1, a2, ..., an (1 β€ ai β€ 109; ai β€ ai + 1).
The next line contains integer m (1 β€ m β€ 105) β the number of boxes. Each of the following m lines contains a pair of integers wi, hi (1 β€ wi β€ n; 1 β€ hi β€ 109) β the size of the i-th thrown box.
The numbers in the lines are separated by spaces.
Output
Print m integers β for each box the height, where the bottom of the box will be after landing. Print the answers for the boxes in the order, in which the boxes are given in the input.
Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
5
1 2 3 6 6
4
1 1
3 1
1 1
4 3
Output
1
3
4
6
Input
3
1 2 3
2
1 1
3 1
Output
1
3
Input
1
1
5
1 2
1 10
1 10
1 10
1 10
Output
1
3
13
23
33
Note
The first sample are shown on the picture.
<image>
Submitted Solution:
```
import sys
n=int(sys.stdin.readline())
l=list(map(int,sys.stdin.readline().split()))
m=int(sys.stdin.readline())
x=0
for i in range(m):
w,h=map(int,sys.stdin.readline().split())
x=max(x,l[w-1])
sys.stdout.write(str(x)+'\n')
x+=h
``` | instruction | 0 | 17,090 | 8 | 34,180 |
Yes | output | 1 | 17,090 | 8 | 34,181 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Dima's got a staircase that consists of n stairs. The first stair is at height a1, the second one is at a2, the last one is at an (1 β€ a1 β€ a2 β€ ... β€ an).
Dima decided to play with the staircase, so he is throwing rectangular boxes at the staircase from above. The i-th box has width wi and height hi. Dima throws each box vertically down on the first wi stairs of the staircase, that is, the box covers stairs with numbers 1, 2, ..., wi. Each thrown box flies vertically down until at least one of the two following events happen:
* the bottom of the box touches the top of a stair;
* the bottom of the box touches the top of a box, thrown earlier.
We only consider touching of the horizontal sides of stairs and boxes, at that touching with the corners isn't taken into consideration. Specifically, that implies that a box with width wi cannot touch the stair number wi + 1.
You are given the description of the staircase and the sequence in which Dima threw the boxes at it. For each box, determine how high the bottom of the box after landing will be. Consider a box to fall after the previous one lands.
Input
The first line contains integer n (1 β€ n β€ 105) β the number of stairs in the staircase. The second line contains a non-decreasing sequence, consisting of n integers, a1, a2, ..., an (1 β€ ai β€ 109; ai β€ ai + 1).
The next line contains integer m (1 β€ m β€ 105) β the number of boxes. Each of the following m lines contains a pair of integers wi, hi (1 β€ wi β€ n; 1 β€ hi β€ 109) β the size of the i-th thrown box.
The numbers in the lines are separated by spaces.
Output
Print m integers β for each box the height, where the bottom of the box will be after landing. Print the answers for the boxes in the order, in which the boxes are given in the input.
Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
5
1 2 3 6 6
4
1 1
3 1
1 1
4 3
Output
1
3
4
6
Input
3
1 2 3
2
1 1
3 1
Output
1
3
Input
1
1
5
1 2
1 10
1 10
1 10
1 10
Output
1
3
13
23
33
Note
The first sample are shown on the picture.
<image>
Submitted Solution:
```
n=int(input())
a=list(map(int,input().split()))
m=int(input())
box=[]
for i in range(m):
box.append(list(map(int,input().split())))
l,w1,h1=0,0,0
ans=[]
for i in range(m):
l=max(l+h1,a[box[i][0]-1])
ans.append(l)
w1=box[i][0]
h1=box[i][1]
print(ans)
``` | instruction | 0 | 17,091 | 8 | 34,182 |
No | output | 1 | 17,091 | 8 | 34,183 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Dima's got a staircase that consists of n stairs. The first stair is at height a1, the second one is at a2, the last one is at an (1 β€ a1 β€ a2 β€ ... β€ an).
Dima decided to play with the staircase, so he is throwing rectangular boxes at the staircase from above. The i-th box has width wi and height hi. Dima throws each box vertically down on the first wi stairs of the staircase, that is, the box covers stairs with numbers 1, 2, ..., wi. Each thrown box flies vertically down until at least one of the two following events happen:
* the bottom of the box touches the top of a stair;
* the bottom of the box touches the top of a box, thrown earlier.
We only consider touching of the horizontal sides of stairs and boxes, at that touching with the corners isn't taken into consideration. Specifically, that implies that a box with width wi cannot touch the stair number wi + 1.
You are given the description of the staircase and the sequence in which Dima threw the boxes at it. For each box, determine how high the bottom of the box after landing will be. Consider a box to fall after the previous one lands.
Input
The first line contains integer n (1 β€ n β€ 105) β the number of stairs in the staircase. The second line contains a non-decreasing sequence, consisting of n integers, a1, a2, ..., an (1 β€ ai β€ 109; ai β€ ai + 1).
The next line contains integer m (1 β€ m β€ 105) β the number of boxes. Each of the following m lines contains a pair of integers wi, hi (1 β€ wi β€ n; 1 β€ hi β€ 109) β the size of the i-th thrown box.
The numbers in the lines are separated by spaces.
Output
Print m integers β for each box the height, where the bottom of the box will be after landing. Print the answers for the boxes in the order, in which the boxes are given in the input.
Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
5
1 2 3 6 6
4
1 1
3 1
1 1
4 3
Output
1
3
4
6
Input
3
1 2 3
2
1 1
3 1
Output
1
3
Input
1
1
5
1 2
1 10
1 10
1 10
1 10
Output
1
3
13
23
33
Note
The first sample are shown on the picture.
<image>
Submitted Solution:
```
n=int(input())
arr=[int(i) for i in input().split()]
arr.insert(0,0)
m=int(input())
last=1
for _ in range(m):
a,b=map(int,input().split())
if a>=last:
print(arr[a])
arr[a]+=b
last=a
else:
print(arr[last])
``` | instruction | 0 | 17,092 | 8 | 34,184 |
No | output | 1 | 17,092 | 8 | 34,185 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Dima's got a staircase that consists of n stairs. The first stair is at height a1, the second one is at a2, the last one is at an (1 β€ a1 β€ a2 β€ ... β€ an).
Dima decided to play with the staircase, so he is throwing rectangular boxes at the staircase from above. The i-th box has width wi and height hi. Dima throws each box vertically down on the first wi stairs of the staircase, that is, the box covers stairs with numbers 1, 2, ..., wi. Each thrown box flies vertically down until at least one of the two following events happen:
* the bottom of the box touches the top of a stair;
* the bottom of the box touches the top of a box, thrown earlier.
We only consider touching of the horizontal sides of stairs and boxes, at that touching with the corners isn't taken into consideration. Specifically, that implies that a box with width wi cannot touch the stair number wi + 1.
You are given the description of the staircase and the sequence in which Dima threw the boxes at it. For each box, determine how high the bottom of the box after landing will be. Consider a box to fall after the previous one lands.
Input
The first line contains integer n (1 β€ n β€ 105) β the number of stairs in the staircase. The second line contains a non-decreasing sequence, consisting of n integers, a1, a2, ..., an (1 β€ ai β€ 109; ai β€ ai + 1).
The next line contains integer m (1 β€ m β€ 105) β the number of boxes. Each of the following m lines contains a pair of integers wi, hi (1 β€ wi β€ n; 1 β€ hi β€ 109) β the size of the i-th thrown box.
The numbers in the lines are separated by spaces.
Output
Print m integers β for each box the height, where the bottom of the box will be after landing. Print the answers for the boxes in the order, in which the boxes are given in the input.
Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
5
1 2 3 6 6
4
1 1
3 1
1 1
4 3
Output
1
3
4
6
Input
3
1 2 3
2
1 1
3 1
Output
1
3
Input
1
1
5
1 2
1 10
1 10
1 10
1 10
Output
1
3
13
23
33
Note
The first sample are shown on the picture.
<image>
Submitted Solution:
```
number = int(input())
stair_case = list(map(int, input().split()))
boxes = int(input())
current = []
levels = {}
mx_width = 0
cnt = 0
for index, x in enumerate(stair_case):
levels[index + 1] = x
for x in range(boxes):
w, h = map(int, input().split())
if w > mx_width and cnt < stair_case[-1]:
cnt = levels[w]
current = h
mx_width = w
else:
cnt = levels[mx_width] + current
current += h
print(cnt)
``` | instruction | 0 | 17,093 | 8 | 34,186 |
No | output | 1 | 17,093 | 8 | 34,187 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Dima's got a staircase that consists of n stairs. The first stair is at height a1, the second one is at a2, the last one is at an (1 β€ a1 β€ a2 β€ ... β€ an).
Dima decided to play with the staircase, so he is throwing rectangular boxes at the staircase from above. The i-th box has width wi and height hi. Dima throws each box vertically down on the first wi stairs of the staircase, that is, the box covers stairs with numbers 1, 2, ..., wi. Each thrown box flies vertically down until at least one of the two following events happen:
* the bottom of the box touches the top of a stair;
* the bottom of the box touches the top of a box, thrown earlier.
We only consider touching of the horizontal sides of stairs and boxes, at that touching with the corners isn't taken into consideration. Specifically, that implies that a box with width wi cannot touch the stair number wi + 1.
You are given the description of the staircase and the sequence in which Dima threw the boxes at it. For each box, determine how high the bottom of the box after landing will be. Consider a box to fall after the previous one lands.
Input
The first line contains integer n (1 β€ n β€ 105) β the number of stairs in the staircase. The second line contains a non-decreasing sequence, consisting of n integers, a1, a2, ..., an (1 β€ ai β€ 109; ai β€ ai + 1).
The next line contains integer m (1 β€ m β€ 105) β the number of boxes. Each of the following m lines contains a pair of integers wi, hi (1 β€ wi β€ n; 1 β€ hi β€ 109) β the size of the i-th thrown box.
The numbers in the lines are separated by spaces.
Output
Print m integers β for each box the height, where the bottom of the box will be after landing. Print the answers for the boxes in the order, in which the boxes are given in the input.
Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
5
1 2 3 6 6
4
1 1
3 1
1 1
4 3
Output
1
3
4
6
Input
3
1 2 3
2
1 1
3 1
Output
1
3
Input
1
1
5
1 2
1 10
1 10
1 10
1 10
Output
1
3
13
23
33
Note
The first sample are shown on the picture.
<image>
Submitted Solution:
```
input()
s={x:y for x,y in enumerate(map(int,input().split()),1)}
for _ in " "*int(input()):
w,h=map(int,input().split())
print(s[w])
s[w]+=h
t=s[w]
w-=1
while w>0:
s[w]=t
w-=1
``` | instruction | 0 | 17,094 | 8 | 34,188 |
No | output | 1 | 17,094 | 8 | 34,189 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Salem gave you n sticks with integer positive lengths a_1, a_2, β¦, a_n.
For every stick, you can change its length to any other positive integer length (that is, either shrink or stretch it). The cost of changing the stick's length from a to b is |a - b|, where |x| means the absolute value of x.
A stick length a_i is called almost good for some integer t if |a_i - t| β€ 1.
Salem asks you to change the lengths of some sticks (possibly all or none), such that all sticks' lengths are almost good for some positive integer t and the total cost of changing is minimum possible. The value of t is not fixed in advance and you can choose it as any positive integer.
As an answer, print the value of t and the minimum cost. If there are multiple optimal choices for t, print any of them.
Input
The first line contains a single integer n (1 β€ n β€ 1000) β the number of sticks.
The second line contains n integers a_i (1 β€ a_i β€ 100) β the lengths of the sticks.
Output
Print the value of t and the minimum possible cost. If there are multiple optimal choices for t, print any of them.
Examples
Input
3
10 1 4
Output
3 7
Input
5
1 1 2 2 3
Output
2 0
Note
In the first example, we can change 1 into 2 and 10 into 4 with cost |1 - 2| + |10 - 4| = 1 + 6 = 7 and the resulting lengths [2, 4, 4] are almost good for t = 3.
In the second example, the sticks lengths are already almost good for t = 2, so we don't have to do anything.
Submitted Solution:
```
n = int(input())
arr = list(map(int,input().split()))
mn,mx = float('inf'), float('-inf')
for a in arr: mn, mx = min(mn,a), max(mx,a)
best_t = None
best_cost = float('inf')
for x in range(mn, mx+1):
sm = 0
for a in arr:
if abs(x-a) > 1: sm+= abs(x-a)-1
if best_cost > sm:
best_cost = sm
best_t = x
print(*(best_t, best_cost))
``` | instruction | 0 | 17,748 | 8 | 35,496 |
Yes | output | 1 | 17,748 | 8 | 35,497 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Salem gave you n sticks with integer positive lengths a_1, a_2, β¦, a_n.
For every stick, you can change its length to any other positive integer length (that is, either shrink or stretch it). The cost of changing the stick's length from a to b is |a - b|, where |x| means the absolute value of x.
A stick length a_i is called almost good for some integer t if |a_i - t| β€ 1.
Salem asks you to change the lengths of some sticks (possibly all or none), such that all sticks' lengths are almost good for some positive integer t and the total cost of changing is minimum possible. The value of t is not fixed in advance and you can choose it as any positive integer.
As an answer, print the value of t and the minimum cost. If there are multiple optimal choices for t, print any of them.
Input
The first line contains a single integer n (1 β€ n β€ 1000) β the number of sticks.
The second line contains n integers a_i (1 β€ a_i β€ 100) β the lengths of the sticks.
Output
Print the value of t and the minimum possible cost. If there are multiple optimal choices for t, print any of them.
Examples
Input
3
10 1 4
Output
3 7
Input
5
1 1 2 2 3
Output
2 0
Note
In the first example, we can change 1 into 2 and 10 into 4 with cost |1 - 2| + |10 - 4| = 1 + 6 = 7 and the resulting lengths [2, 4, 4] are almost good for t = 3.
In the second example, the sticks lengths are already almost good for t = 2, so we don't have to do anything.
Submitted Solution:
```
from typing import List
_max_a = 100
def dist(x: int, y: int):
return max(abs(x - y) - 1, 0)
def cost(a: List[int], t: int, n: int) -> int:
ans = 0
for i in range(n):
ans += dist(a[i], t)
return ans
if __name__ == '__main__':
n = int(input())
a = list(map(int, input().split()))
answers = []
for t in range(1, _max_a + 1):
answers.append(cost(a, t, n))
optimal_cost = min(answers)
optimal_t = answers.index(optimal_cost) + 1
print(optimal_t, optimal_cost)
``` | instruction | 0 | 17,749 | 8 | 35,498 |
Yes | output | 1 | 17,749 | 8 | 35,499 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Salem gave you n sticks with integer positive lengths a_1, a_2, β¦, a_n.
For every stick, you can change its length to any other positive integer length (that is, either shrink or stretch it). The cost of changing the stick's length from a to b is |a - b|, where |x| means the absolute value of x.
A stick length a_i is called almost good for some integer t if |a_i - t| β€ 1.
Salem asks you to change the lengths of some sticks (possibly all or none), such that all sticks' lengths are almost good for some positive integer t and the total cost of changing is minimum possible. The value of t is not fixed in advance and you can choose it as any positive integer.
As an answer, print the value of t and the minimum cost. If there are multiple optimal choices for t, print any of them.
Input
The first line contains a single integer n (1 β€ n β€ 1000) β the number of sticks.
The second line contains n integers a_i (1 β€ a_i β€ 100) β the lengths of the sticks.
Output
Print the value of t and the minimum possible cost. If there are multiple optimal choices for t, print any of them.
Examples
Input
3
10 1 4
Output
3 7
Input
5
1 1 2 2 3
Output
2 0
Note
In the first example, we can change 1 into 2 and 10 into 4 with cost |1 - 2| + |10 - 4| = 1 + 6 = 7 and the resulting lengths [2, 4, 4] are almost good for t = 3.
In the second example, the sticks lengths are already almost good for t = 2, so we don't have to do anything.
Submitted Solution:
```
n = int(input())
a = list(map(int,input().split()))
min_cost = 9999999999999
new_t = 0
for t in range(1,101):
cost = 0
for j in range(n):
if abs(a[j]-t)<=1:
continue
else:
cost+= (abs(a[j]-t)-1)
if cost<min_cost:
min_cost = cost
new_t = t
print(new_t,min_cost)
``` | instruction | 0 | 17,750 | 8 | 35,500 |
Yes | output | 1 | 17,750 | 8 | 35,501 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Salem gave you n sticks with integer positive lengths a_1, a_2, β¦, a_n.
For every stick, you can change its length to any other positive integer length (that is, either shrink or stretch it). The cost of changing the stick's length from a to b is |a - b|, where |x| means the absolute value of x.
A stick length a_i is called almost good for some integer t if |a_i - t| β€ 1.
Salem asks you to change the lengths of some sticks (possibly all or none), such that all sticks' lengths are almost good for some positive integer t and the total cost of changing is minimum possible. The value of t is not fixed in advance and you can choose it as any positive integer.
As an answer, print the value of t and the minimum cost. If there are multiple optimal choices for t, print any of them.
Input
The first line contains a single integer n (1 β€ n β€ 1000) β the number of sticks.
The second line contains n integers a_i (1 β€ a_i β€ 100) β the lengths of the sticks.
Output
Print the value of t and the minimum possible cost. If there are multiple optimal choices for t, print any of them.
Examples
Input
3
10 1 4
Output
3 7
Input
5
1 1 2 2 3
Output
2 0
Note
In the first example, we can change 1 into 2 and 10 into 4 with cost |1 - 2| + |10 - 4| = 1 + 6 = 7 and the resulting lengths [2, 4, 4] are almost good for t = 3.
In the second example, the sticks lengths are already almost good for t = 2, so we don't have to do anything.
Submitted Solution:
```
from collections import defaultdict,deque
#a,b,c = map(int,input().split())
n = int(input())
a = list(map(int,input().split()))
m = sum(a)//n
best = None
best_score = sum(a)
for x in range(m-10,m+10):
current = 0
for c in a:
if abs(c-x) <= 1:continue
elif c>x:
current += c-(x+1)
else:
current += (x-1)-c
if current<best_score and x!=0:
best_score = current
best = x
print (best, best_score)
# for _ in range(t):
# n,s,t = map(int,input().split())
# print (n-min(s,t)+1)
``` | instruction | 0 | 17,751 | 8 | 35,502 |
No | output | 1 | 17,751 | 8 | 35,503 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Salem gave you n sticks with integer positive lengths a_1, a_2, β¦, a_n.
For every stick, you can change its length to any other positive integer length (that is, either shrink or stretch it). The cost of changing the stick's length from a to b is |a - b|, where |x| means the absolute value of x.
A stick length a_i is called almost good for some integer t if |a_i - t| β€ 1.
Salem asks you to change the lengths of some sticks (possibly all or none), such that all sticks' lengths are almost good for some positive integer t and the total cost of changing is minimum possible. The value of t is not fixed in advance and you can choose it as any positive integer.
As an answer, print the value of t and the minimum cost. If there are multiple optimal choices for t, print any of them.
Input
The first line contains a single integer n (1 β€ n β€ 1000) β the number of sticks.
The second line contains n integers a_i (1 β€ a_i β€ 100) β the lengths of the sticks.
Output
Print the value of t and the minimum possible cost. If there are multiple optimal choices for t, print any of them.
Examples
Input
3
10 1 4
Output
3 7
Input
5
1 1 2 2 3
Output
2 0
Note
In the first example, we can change 1 into 2 and 10 into 4 with cost |1 - 2| + |10 - 4| = 1 + 6 = 7 and the resulting lengths [2, 4, 4] are almost good for t = 3.
In the second example, the sticks lengths are already almost good for t = 2, so we don't have to do anything.
Submitted Solution:
```
n=int(input())
l1=list(map(int,input().split()))
l2=list(set(l1))
s=sum(l2)
s=s//len(l2)
cost=0
for i in range(n):
if abs(l1[i]-s)>1:
cost+=abs(l1[i]-s)-1
print(s,cost)
``` | instruction | 0 | 17,752 | 8 | 35,504 |
No | output | 1 | 17,752 | 8 | 35,505 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Salem gave you n sticks with integer positive lengths a_1, a_2, β¦, a_n.
For every stick, you can change its length to any other positive integer length (that is, either shrink or stretch it). The cost of changing the stick's length from a to b is |a - b|, where |x| means the absolute value of x.
A stick length a_i is called almost good for some integer t if |a_i - t| β€ 1.
Salem asks you to change the lengths of some sticks (possibly all or none), such that all sticks' lengths are almost good for some positive integer t and the total cost of changing is minimum possible. The value of t is not fixed in advance and you can choose it as any positive integer.
As an answer, print the value of t and the minimum cost. If there are multiple optimal choices for t, print any of them.
Input
The first line contains a single integer n (1 β€ n β€ 1000) β the number of sticks.
The second line contains n integers a_i (1 β€ a_i β€ 100) β the lengths of the sticks.
Output
Print the value of t and the minimum possible cost. If there are multiple optimal choices for t, print any of them.
Examples
Input
3
10 1 4
Output
3 7
Input
5
1 1 2 2 3
Output
2 0
Note
In the first example, we can change 1 into 2 and 10 into 4 with cost |1 - 2| + |10 - 4| = 1 + 6 = 7 and the resulting lengths [2, 4, 4] are almost good for t = 3.
In the second example, the sticks lengths are already almost good for t = 2, so we don't have to do anything.
Submitted Solution:
```
import math
n=int(input())
a=list(map(int,input().split()))
x=math.ceil(sum(a)/n)
y=sum(a)//n
ans=0
for i in range(n):
if a[i]>x+1:
ans=ans+a[i]-x-1
elif a[i]<x-1:
ans=ans+x-1-a[i]
ans1=0
for i in range(n):
if a[i]>y+1:
ans1=ans1+a[i]-y-1
elif a[i]<x-1:
ans1=ans1+y-1-a[i]
if ans<ans1:
print(x,ans)
else:
print(y,ans1)
``` | instruction | 0 | 17,753 | 8 | 35,506 |
No | output | 1 | 17,753 | 8 | 35,507 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Salem gave you n sticks with integer positive lengths a_1, a_2, β¦, a_n.
For every stick, you can change its length to any other positive integer length (that is, either shrink or stretch it). The cost of changing the stick's length from a to b is |a - b|, where |x| means the absolute value of x.
A stick length a_i is called almost good for some integer t if |a_i - t| β€ 1.
Salem asks you to change the lengths of some sticks (possibly all or none), such that all sticks' lengths are almost good for some positive integer t and the total cost of changing is minimum possible. The value of t is not fixed in advance and you can choose it as any positive integer.
As an answer, print the value of t and the minimum cost. If there are multiple optimal choices for t, print any of them.
Input
The first line contains a single integer n (1 β€ n β€ 1000) β the number of sticks.
The second line contains n integers a_i (1 β€ a_i β€ 100) β the lengths of the sticks.
Output
Print the value of t and the minimum possible cost. If there are multiple optimal choices for t, print any of them.
Examples
Input
3
10 1 4
Output
3 7
Input
5
1 1 2 2 3
Output
2 0
Note
In the first example, we can change 1 into 2 and 10 into 4 with cost |1 - 2| + |10 - 4| = 1 + 6 = 7 and the resulting lengths [2, 4, 4] are almost good for t = 3.
In the second example, the sticks lengths are already almost good for t = 2, so we don't have to do anything.
Submitted Solution:
```
import math
# inputs
n = input()
a = list(map(int,input().split()))
#for x in a:
# print(x)
a.sort()
#for x in a:
# print(x)
ans_i = 1
ans_s = 1000000000
for t in range(1, 101):
sum = 0
for i in a:
if abs(i-t)>=1:
if(t in a):
sum += abs(i-t)-1
else:
sum += abs(i-t)
if sum < ans_s:
ans_s = sum
ans_i = t
print(ans_i, ans_s)
``` | instruction | 0 | 17,754 | 8 | 35,508 |
No | output | 1 | 17,754 | 8 | 35,509 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Vasya had n boxes with balls in the room. The boxes stood in a row and were numbered with numbers from 1 to n from left to right.
Once Vasya chose one of the boxes, let's assume that its number is i, took all balls out from it (it is guaranteed that this box originally had at least one ball), and began putting balls (one at a time) to the boxes with numbers i + 1, i + 2, i + 3 and so on. If Vasya puts a ball into the box number n, then the next ball goes to box 1, the next one goes to box 2 and so on. He did it until he had no balls left in his hands. It is possible that Vasya puts multiple balls to the same box, and it is also possible that one or more balls will go to the box number i. If i = n, Vasya puts the first ball into the box number 1, then the next ball goes to box 2 and so on.
For example, let's suppose that initially Vasya had four boxes, and the first box had 3 balls, the second one had 2, the third one had 5 and the fourth one had 4 balls. Then, if i = 3, then Vasya will take all five balls out of the third box and put them in the boxes with numbers: 4, 1, 2, 3, 4. After all Vasya's actions the balls will lie in the boxes as follows: in the first box there are 4 balls, 3 in the second one, 1 in the third one and 6 in the fourth one.
At this point Vasya has completely forgotten the original arrangement of the balls in the boxes, but he knows how they are arranged now, and the number x β the number of the box, where he put the last of the taken out balls.
He asks you to help to find the initial arrangement of the balls in the boxes.
Input
The first line of the input contains two integers n and x (2 β€ n β€ 105, 1 β€ x β€ n), that represent the number of the boxes and the index of the box that got the last ball from Vasya, correspondingly. The second line contains n space-separated integers a1, a2, ..., an, where integer ai (0 β€ ai β€ 109, ax β 0) represents the number of balls in the box with index i after Vasya completes all the actions.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use the cin, cout streams or the %I64d specifier.
Output
Print n integers, where the i-th one represents the number of balls in the box number i before Vasya starts acting. Separate the numbers in the output by spaces. If there are multiple correct solutions, you are allowed to print any of them.
Examples
Input
4 4
4 3 1 6
Output
3 2 5 4
Input
5 2
3 2 0 2 7
Output
2 1 4 1 6
Input
3 3
2 3 1
Output
1 2 3 | instruction | 0 | 18,832 | 8 | 37,664 |
Tags: constructive algorithms, greedy, implementation
Correct Solution:
```
# arr = list(map(int,input().split()))
# for i in range(1,len(arr)):
# k=arr[i]
# j=i-1
# while j>=0 and arr[j]>k:
# arr[j+1]=arr[j]
# j=j-1
# arr[j+1]=k
# print(arr)
# l=list(map(int,input().split()))
# for i in range(len(l)):
# mid_idx=i
# for j in range(i+1,len(l)):
# if l[mid_idx]>l[j]:
# mid_idx=j
# l[i],l[mid_idx]=l[mid_idx],l[i]
# print(l)
# def merge(l,p,r):
# if p<r:
# q=(p+(r-1))//2
# merge(l,p,q)
# merge(l,q+1,r)
# l=list(map(int,input().split()))
# merge(l,0,len(l)-1)
# for i in range(len(l)):
# print(l[i]
n,k=map(int,input().split())
l=list(map(int,input().split()))
a=l.index(min(l))
m=l[a]+1
c=0
f=k-1
for i in range(n):
if l[f]==l[a]:
d=f
break
f=(f-1)%n
for i in range(n):
l[d]-=m
c+=m
if d==k-1:
m-=1
d=(d+1)%n
l[d]=c-1
print(*l)
``` | output | 1 | 18,832 | 8 | 37,665 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Vasya had n boxes with balls in the room. The boxes stood in a row and were numbered with numbers from 1 to n from left to right.
Once Vasya chose one of the boxes, let's assume that its number is i, took all balls out from it (it is guaranteed that this box originally had at least one ball), and began putting balls (one at a time) to the boxes with numbers i + 1, i + 2, i + 3 and so on. If Vasya puts a ball into the box number n, then the next ball goes to box 1, the next one goes to box 2 and so on. He did it until he had no balls left in his hands. It is possible that Vasya puts multiple balls to the same box, and it is also possible that one or more balls will go to the box number i. If i = n, Vasya puts the first ball into the box number 1, then the next ball goes to box 2 and so on.
For example, let's suppose that initially Vasya had four boxes, and the first box had 3 balls, the second one had 2, the third one had 5 and the fourth one had 4 balls. Then, if i = 3, then Vasya will take all five balls out of the third box and put them in the boxes with numbers: 4, 1, 2, 3, 4. After all Vasya's actions the balls will lie in the boxes as follows: in the first box there are 4 balls, 3 in the second one, 1 in the third one and 6 in the fourth one.
At this point Vasya has completely forgotten the original arrangement of the balls in the boxes, but he knows how they are arranged now, and the number x β the number of the box, where he put the last of the taken out balls.
He asks you to help to find the initial arrangement of the balls in the boxes.
Input
The first line of the input contains two integers n and x (2 β€ n β€ 105, 1 β€ x β€ n), that represent the number of the boxes and the index of the box that got the last ball from Vasya, correspondingly. The second line contains n space-separated integers a1, a2, ..., an, where integer ai (0 β€ ai β€ 109, ax β 0) represents the number of balls in the box with index i after Vasya completes all the actions.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use the cin, cout streams or the %I64d specifier.
Output
Print n integers, where the i-th one represents the number of balls in the box number i before Vasya starts acting. Separate the numbers in the output by spaces. If there are multiple correct solutions, you are allowed to print any of them.
Examples
Input
4 4
4 3 1 6
Output
3 2 5 4
Input
5 2
3 2 0 2 7
Output
2 1 4 1 6
Input
3 3
2 3 1
Output
1 2 3 | instruction | 0 | 18,833 | 8 | 37,666 |
Tags: constructive algorithms, greedy, implementation
Correct Solution:
```
n, x = map(int, input().split())
a = list(map(int, input().split()))
idx = x % n
for j in range(x, x+n):
if a[j % n] <= a[idx]:
idx = j % n
temp = a[idx]
a[idx] += n * temp
a = [i - temp for i in a]
j = idx + 1
while j % n != x % n:
a[j % n] -= 1
j += 1
a[idx] += 1
print(*a)
``` | output | 1 | 18,833 | 8 | 37,667 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Vasya had n boxes with balls in the room. The boxes stood in a row and were numbered with numbers from 1 to n from left to right.
Once Vasya chose one of the boxes, let's assume that its number is i, took all balls out from it (it is guaranteed that this box originally had at least one ball), and began putting balls (one at a time) to the boxes with numbers i + 1, i + 2, i + 3 and so on. If Vasya puts a ball into the box number n, then the next ball goes to box 1, the next one goes to box 2 and so on. He did it until he had no balls left in his hands. It is possible that Vasya puts multiple balls to the same box, and it is also possible that one or more balls will go to the box number i. If i = n, Vasya puts the first ball into the box number 1, then the next ball goes to box 2 and so on.
For example, let's suppose that initially Vasya had four boxes, and the first box had 3 balls, the second one had 2, the third one had 5 and the fourth one had 4 balls. Then, if i = 3, then Vasya will take all five balls out of the third box and put them in the boxes with numbers: 4, 1, 2, 3, 4. After all Vasya's actions the balls will lie in the boxes as follows: in the first box there are 4 balls, 3 in the second one, 1 in the third one and 6 in the fourth one.
At this point Vasya has completely forgotten the original arrangement of the balls in the boxes, but he knows how they are arranged now, and the number x β the number of the box, where he put the last of the taken out balls.
He asks you to help to find the initial arrangement of the balls in the boxes.
Input
The first line of the input contains two integers n and x (2 β€ n β€ 105, 1 β€ x β€ n), that represent the number of the boxes and the index of the box that got the last ball from Vasya, correspondingly. The second line contains n space-separated integers a1, a2, ..., an, where integer ai (0 β€ ai β€ 109, ax β 0) represents the number of balls in the box with index i after Vasya completes all the actions.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use the cin, cout streams or the %I64d specifier.
Output
Print n integers, where the i-th one represents the number of balls in the box number i before Vasya starts acting. Separate the numbers in the output by spaces. If there are multiple correct solutions, you are allowed to print any of them.
Examples
Input
4 4
4 3 1 6
Output
3 2 5 4
Input
5 2
3 2 0 2 7
Output
2 1 4 1 6
Input
3 3
2 3 1
Output
1 2 3 | instruction | 0 | 18,834 | 8 | 37,668 |
Tags: constructive algorithms, greedy, implementation
Correct Solution:
```
n,l=input().split()
n=int(n)
l=int(l)
l=l-1
a=list(map(int,input().split()))
min=float('inf')
for i in range(n-1,-1,-1):
if(a[i]<min):
min=a[i]
pos=i
if(a[l]==min):
pos=l
if(l>=pos):
for i in range(0,n):
a[i]-=min
for i in range(pos+1,l+1):
a[i]-=1
a[pos]=n*min+l-pos
else:
found=0
for i in range(l,-1,-1):
if(a[i]==min):
pos=i
found=1
break
if(found==1):
for i in range(0,n):
a[i]-=min
for i in range(pos+1,l+1):
a[i]-=1
a[pos]=n*min+l-pos
else:
for i in range(0,n):
a[i]-=min
for i in range(pos+1,n):
a[i]-=1
for i in range(0,l+1):
a[i]-=1
a[pos]=n*min+n-pos+l
for i in range(0,n):
print(a[i],end=' ')
``` | output | 1 | 18,834 | 8 | 37,669 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Vasya had n boxes with balls in the room. The boxes stood in a row and were numbered with numbers from 1 to n from left to right.
Once Vasya chose one of the boxes, let's assume that its number is i, took all balls out from it (it is guaranteed that this box originally had at least one ball), and began putting balls (one at a time) to the boxes with numbers i + 1, i + 2, i + 3 and so on. If Vasya puts a ball into the box number n, then the next ball goes to box 1, the next one goes to box 2 and so on. He did it until he had no balls left in his hands. It is possible that Vasya puts multiple balls to the same box, and it is also possible that one or more balls will go to the box number i. If i = n, Vasya puts the first ball into the box number 1, then the next ball goes to box 2 and so on.
For example, let's suppose that initially Vasya had four boxes, and the first box had 3 balls, the second one had 2, the third one had 5 and the fourth one had 4 balls. Then, if i = 3, then Vasya will take all five balls out of the third box and put them in the boxes with numbers: 4, 1, 2, 3, 4. After all Vasya's actions the balls will lie in the boxes as follows: in the first box there are 4 balls, 3 in the second one, 1 in the third one and 6 in the fourth one.
At this point Vasya has completely forgotten the original arrangement of the balls in the boxes, but he knows how they are arranged now, and the number x β the number of the box, where he put the last of the taken out balls.
He asks you to help to find the initial arrangement of the balls in the boxes.
Input
The first line of the input contains two integers n and x (2 β€ n β€ 105, 1 β€ x β€ n), that represent the number of the boxes and the index of the box that got the last ball from Vasya, correspondingly. The second line contains n space-separated integers a1, a2, ..., an, where integer ai (0 β€ ai β€ 109, ax β 0) represents the number of balls in the box with index i after Vasya completes all the actions.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use the cin, cout streams or the %I64d specifier.
Output
Print n integers, where the i-th one represents the number of balls in the box number i before Vasya starts acting. Separate the numbers in the output by spaces. If there are multiple correct solutions, you are allowed to print any of them.
Examples
Input
4 4
4 3 1 6
Output
3 2 5 4
Input
5 2
3 2 0 2 7
Output
2 1 4 1 6
Input
3 3
2 3 1
Output
1 2 3 | instruction | 0 | 18,835 | 8 | 37,670 |
Tags: constructive algorithms, greedy, implementation
Correct Solution:
```
n,x=map(int,input().split())
a=list(map(int,input().split()))
x-=1
y=max(0,min(a))
for i in range(n):
a[i]-=y
flag=False
cnt=0
for i in range(x,-1,-1):
if a[i]==0:
a[i]=cnt+(y*n)
flag=True
break
a[i]-=1
cnt+=1
for i in range(n-1,x,-1):
if flag:
break
if a[i]==0:
a[i]=cnt+(y*n)
break
a[i]-=1
cnt+=1
print(*a)
``` | output | 1 | 18,835 | 8 | 37,671 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Vasya had n boxes with balls in the room. The boxes stood in a row and were numbered with numbers from 1 to n from left to right.
Once Vasya chose one of the boxes, let's assume that its number is i, took all balls out from it (it is guaranteed that this box originally had at least one ball), and began putting balls (one at a time) to the boxes with numbers i + 1, i + 2, i + 3 and so on. If Vasya puts a ball into the box number n, then the next ball goes to box 1, the next one goes to box 2 and so on. He did it until he had no balls left in his hands. It is possible that Vasya puts multiple balls to the same box, and it is also possible that one or more balls will go to the box number i. If i = n, Vasya puts the first ball into the box number 1, then the next ball goes to box 2 and so on.
For example, let's suppose that initially Vasya had four boxes, and the first box had 3 balls, the second one had 2, the third one had 5 and the fourth one had 4 balls. Then, if i = 3, then Vasya will take all five balls out of the third box and put them in the boxes with numbers: 4, 1, 2, 3, 4. After all Vasya's actions the balls will lie in the boxes as follows: in the first box there are 4 balls, 3 in the second one, 1 in the third one and 6 in the fourth one.
At this point Vasya has completely forgotten the original arrangement of the balls in the boxes, but he knows how they are arranged now, and the number x β the number of the box, where he put the last of the taken out balls.
He asks you to help to find the initial arrangement of the balls in the boxes.
Input
The first line of the input contains two integers n and x (2 β€ n β€ 105, 1 β€ x β€ n), that represent the number of the boxes and the index of the box that got the last ball from Vasya, correspondingly. The second line contains n space-separated integers a1, a2, ..., an, where integer ai (0 β€ ai β€ 109, ax β 0) represents the number of balls in the box with index i after Vasya completes all the actions.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use the cin, cout streams or the %I64d specifier.
Output
Print n integers, where the i-th one represents the number of balls in the box number i before Vasya starts acting. Separate the numbers in the output by spaces. If there are multiple correct solutions, you are allowed to print any of them.
Examples
Input
4 4
4 3 1 6
Output
3 2 5 4
Input
5 2
3 2 0 2 7
Output
2 1 4 1 6
Input
3 3
2 3 1
Output
1 2 3 | instruction | 0 | 18,836 | 8 | 37,672 |
Tags: constructive algorithms, greedy, implementation
Correct Solution:
```
n, x = map(int, input().split())
x = x - 1
l = list(map(int, input().split()))
min_index, min_value = -1, 10 ** 9 + 7
nb_seen = 0
cur = x
while nb_seen != n:
if min_value > l[cur]:
min_value = l[cur]
min_index = cur
cur = (n - 1 + cur) % n
nb_seen += 1
min_value = l[min_index]
for i in range(n):
l[i] -= min_value
nb_el = 0
cur = x
while l[cur] != 0:
l[cur] -= 1
cur = (n - 1 + cur) % n
nb_el += 1
l[min_index] += n * min_value + nb_el
print(' '.join(list(map(str, l))))
``` | output | 1 | 18,836 | 8 | 37,673 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Vasya had n boxes with balls in the room. The boxes stood in a row and were numbered with numbers from 1 to n from left to right.
Once Vasya chose one of the boxes, let's assume that its number is i, took all balls out from it (it is guaranteed that this box originally had at least one ball), and began putting balls (one at a time) to the boxes with numbers i + 1, i + 2, i + 3 and so on. If Vasya puts a ball into the box number n, then the next ball goes to box 1, the next one goes to box 2 and so on. He did it until he had no balls left in his hands. It is possible that Vasya puts multiple balls to the same box, and it is also possible that one or more balls will go to the box number i. If i = n, Vasya puts the first ball into the box number 1, then the next ball goes to box 2 and so on.
For example, let's suppose that initially Vasya had four boxes, and the first box had 3 balls, the second one had 2, the third one had 5 and the fourth one had 4 balls. Then, if i = 3, then Vasya will take all five balls out of the third box and put them in the boxes with numbers: 4, 1, 2, 3, 4. After all Vasya's actions the balls will lie in the boxes as follows: in the first box there are 4 balls, 3 in the second one, 1 in the third one and 6 in the fourth one.
At this point Vasya has completely forgotten the original arrangement of the balls in the boxes, but he knows how they are arranged now, and the number x β the number of the box, where he put the last of the taken out balls.
He asks you to help to find the initial arrangement of the balls in the boxes.
Input
The first line of the input contains two integers n and x (2 β€ n β€ 105, 1 β€ x β€ n), that represent the number of the boxes and the index of the box that got the last ball from Vasya, correspondingly. The second line contains n space-separated integers a1, a2, ..., an, where integer ai (0 β€ ai β€ 109, ax β 0) represents the number of balls in the box with index i after Vasya completes all the actions.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use the cin, cout streams or the %I64d specifier.
Output
Print n integers, where the i-th one represents the number of balls in the box number i before Vasya starts acting. Separate the numbers in the output by spaces. If there are multiple correct solutions, you are allowed to print any of them.
Examples
Input
4 4
4 3 1 6
Output
3 2 5 4
Input
5 2
3 2 0 2 7
Output
2 1 4 1 6
Input
3 3
2 3 1
Output
1 2 3 | instruction | 0 | 18,837 | 8 | 37,674 |
Tags: constructive algorithms, greedy, implementation
Correct Solution:
```
n,x=map(int,input().split())
A={}
L=list(map(int,input().split()))
minn=min(L)
ind=x-1
while(L[ind]!=minn):
ind-=1
if(ind==-1):
ind=n-1
iterations=L[ind]
Diff=[0]*n
r=1
inc=True
if(x-1==ind):
inc=False
i=ind+1
start=True
rem=0
while(i!=ind+1 or start):
start=False
if(i==n):
i=0
if(i==x-1 and inc):
rem+=1
inc=False
L[i]-=iterations+r
i+=1
continue
if(inc):
rem+=1
L[i]-=iterations+r
else:
L[i]-=iterations
i+=1
if(ind!=0):
if(L[0]<0):
while(1):
x=1
print(L[0],end="")
else:
print(iterations*n+rem,end="")
for i in range(1,n):
if(i==ind):
print(" "+str(iterations*n+rem),end="")
continue
if(L[i]<0):
while(1):
x=1
print(" "+str(L[i]),end="")
print()
``` | output | 1 | 18,837 | 8 | 37,675 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Vasya had n boxes with balls in the room. The boxes stood in a row and were numbered with numbers from 1 to n from left to right.
Once Vasya chose one of the boxes, let's assume that its number is i, took all balls out from it (it is guaranteed that this box originally had at least one ball), and began putting balls (one at a time) to the boxes with numbers i + 1, i + 2, i + 3 and so on. If Vasya puts a ball into the box number n, then the next ball goes to box 1, the next one goes to box 2 and so on. He did it until he had no balls left in his hands. It is possible that Vasya puts multiple balls to the same box, and it is also possible that one or more balls will go to the box number i. If i = n, Vasya puts the first ball into the box number 1, then the next ball goes to box 2 and so on.
For example, let's suppose that initially Vasya had four boxes, and the first box had 3 balls, the second one had 2, the third one had 5 and the fourth one had 4 balls. Then, if i = 3, then Vasya will take all five balls out of the third box and put them in the boxes with numbers: 4, 1, 2, 3, 4. After all Vasya's actions the balls will lie in the boxes as follows: in the first box there are 4 balls, 3 in the second one, 1 in the third one and 6 in the fourth one.
At this point Vasya has completely forgotten the original arrangement of the balls in the boxes, but he knows how they are arranged now, and the number x β the number of the box, where he put the last of the taken out balls.
He asks you to help to find the initial arrangement of the balls in the boxes.
Input
The first line of the input contains two integers n and x (2 β€ n β€ 105, 1 β€ x β€ n), that represent the number of the boxes and the index of the box that got the last ball from Vasya, correspondingly. The second line contains n space-separated integers a1, a2, ..., an, where integer ai (0 β€ ai β€ 109, ax β 0) represents the number of balls in the box with index i after Vasya completes all the actions.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use the cin, cout streams or the %I64d specifier.
Output
Print n integers, where the i-th one represents the number of balls in the box number i before Vasya starts acting. Separate the numbers in the output by spaces. If there are multiple correct solutions, you are allowed to print any of them.
Examples
Input
4 4
4 3 1 6
Output
3 2 5 4
Input
5 2
3 2 0 2 7
Output
2 1 4 1 6
Input
3 3
2 3 1
Output
1 2 3 | instruction | 0 | 18,838 | 8 | 37,676 |
Tags: constructive algorithms, greedy, implementation
Correct Solution:
```
import sys
input = sys.stdin.readline
def read_int():
return int(input().strip())
def read_ints():
return list(map(int, input().strip().split(' ')))
def solve():
"""
4 4
4 3 1 6
3 2 4 5
3 2 5 4
"""
n, x = read_ints()
a = read_ints()
last_min_j = x%n
for j in range(x, x+n):
if a[j%n] <= a[last_min_j]:
last_min_j = j%n
temp = a[last_min_j]
a[last_min_j] += n*temp
a = [a0-temp for a0 in a]
j = last_min_j+1
while j%n != x%n:
a[j%n] -= 1
j += 1
a[last_min_j] += 1
print(*a)
if __name__ == '__main__':
solve()
``` | output | 1 | 18,838 | 8 | 37,677 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Vasya had n boxes with balls in the room. The boxes stood in a row and were numbered with numbers from 1 to n from left to right.
Once Vasya chose one of the boxes, let's assume that its number is i, took all balls out from it (it is guaranteed that this box originally had at least one ball), and began putting balls (one at a time) to the boxes with numbers i + 1, i + 2, i + 3 and so on. If Vasya puts a ball into the box number n, then the next ball goes to box 1, the next one goes to box 2 and so on. He did it until he had no balls left in his hands. It is possible that Vasya puts multiple balls to the same box, and it is also possible that one or more balls will go to the box number i. If i = n, Vasya puts the first ball into the box number 1, then the next ball goes to box 2 and so on.
For example, let's suppose that initially Vasya had four boxes, and the first box had 3 balls, the second one had 2, the third one had 5 and the fourth one had 4 balls. Then, if i = 3, then Vasya will take all five balls out of the third box and put them in the boxes with numbers: 4, 1, 2, 3, 4. After all Vasya's actions the balls will lie in the boxes as follows: in the first box there are 4 balls, 3 in the second one, 1 in the third one and 6 in the fourth one.
At this point Vasya has completely forgotten the original arrangement of the balls in the boxes, but he knows how they are arranged now, and the number x β the number of the box, where he put the last of the taken out balls.
He asks you to help to find the initial arrangement of the balls in the boxes.
Input
The first line of the input contains two integers n and x (2 β€ n β€ 105, 1 β€ x β€ n), that represent the number of the boxes and the index of the box that got the last ball from Vasya, correspondingly. The second line contains n space-separated integers a1, a2, ..., an, where integer ai (0 β€ ai β€ 109, ax β 0) represents the number of balls in the box with index i after Vasya completes all the actions.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use the cin, cout streams or the %I64d specifier.
Output
Print n integers, where the i-th one represents the number of balls in the box number i before Vasya starts acting. Separate the numbers in the output by spaces. If there are multiple correct solutions, you are allowed to print any of them.
Examples
Input
4 4
4 3 1 6
Output
3 2 5 4
Input
5 2
3 2 0 2 7
Output
2 1 4 1 6
Input
3 3
2 3 1
Output
1 2 3 | instruction | 0 | 18,839 | 8 | 37,678 |
Tags: constructive algorithms, greedy, implementation
Correct Solution:
```
from math import inf
n, x = map(int, input().split())
a = list(map(int, input().split()))
x -= 1
mx = inf
mi = None
for i in range(x, x - n, -1):
if a[i] < mx:
mx = a[i]
mi = i
mi %= n
for i in range(n):
a[i] -= mx
a[mi] = mx * n + (x - mi) % n
for i in range(mi + 1 - (n if x < mi else 0), x + 1):
a[i] -= 1
print(' '.join(map(str, a)))
``` | output | 1 | 18,839 | 8 | 37,679 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little Vasya had n boxes with balls in the room. The boxes stood in a row and were numbered with numbers from 1 to n from left to right.
Once Vasya chose one of the boxes, let's assume that its number is i, took all balls out from it (it is guaranteed that this box originally had at least one ball), and began putting balls (one at a time) to the boxes with numbers i + 1, i + 2, i + 3 and so on. If Vasya puts a ball into the box number n, then the next ball goes to box 1, the next one goes to box 2 and so on. He did it until he had no balls left in his hands. It is possible that Vasya puts multiple balls to the same box, and it is also possible that one or more balls will go to the box number i. If i = n, Vasya puts the first ball into the box number 1, then the next ball goes to box 2 and so on.
For example, let's suppose that initially Vasya had four boxes, and the first box had 3 balls, the second one had 2, the third one had 5 and the fourth one had 4 balls. Then, if i = 3, then Vasya will take all five balls out of the third box and put them in the boxes with numbers: 4, 1, 2, 3, 4. After all Vasya's actions the balls will lie in the boxes as follows: in the first box there are 4 balls, 3 in the second one, 1 in the third one and 6 in the fourth one.
At this point Vasya has completely forgotten the original arrangement of the balls in the boxes, but he knows how they are arranged now, and the number x β the number of the box, where he put the last of the taken out balls.
He asks you to help to find the initial arrangement of the balls in the boxes.
Input
The first line of the input contains two integers n and x (2 β€ n β€ 105, 1 β€ x β€ n), that represent the number of the boxes and the index of the box that got the last ball from Vasya, correspondingly. The second line contains n space-separated integers a1, a2, ..., an, where integer ai (0 β€ ai β€ 109, ax β 0) represents the number of balls in the box with index i after Vasya completes all the actions.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use the cin, cout streams or the %I64d specifier.
Output
Print n integers, where the i-th one represents the number of balls in the box number i before Vasya starts acting. Separate the numbers in the output by spaces. If there are multiple correct solutions, you are allowed to print any of them.
Examples
Input
4 4
4 3 1 6
Output
3 2 5 4
Input
5 2
3 2 0 2 7
Output
2 1 4 1 6
Input
3 3
2 3 1
Output
1 2 3
Submitted Solution:
```
def main():
n, x = map(int,input().split())
a = [int(i) for i in input().split()]
j = x - 1
z = min(a)
while a[j] != z:
if j == 0:
j = n - 1
else:
j -= 1
m = a[j]
k = 0
if x - 1 > j:
for i in range(n):
if j < i <= x - 1:
a[i] -= (m + 1)
k += (m + 1)
else:
a[i] -= m
k += m
a[j] += k
elif x - 1 < j:
for i in range(n):
if x - 1 < i <= j:
a[i] -= m
k += m
else:
a[i] -=(m + 1)
k += (m + 1)
a[j] += k
else:
for i in range(n):
a[i] -= m
k += m
a[j] += k
print(*a)
main()
``` | instruction | 0 | 18,840 | 8 | 37,680 |
Yes | output | 1 | 18,840 | 8 | 37,681 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little Vasya had n boxes with balls in the room. The boxes stood in a row and were numbered with numbers from 1 to n from left to right.
Once Vasya chose one of the boxes, let's assume that its number is i, took all balls out from it (it is guaranteed that this box originally had at least one ball), and began putting balls (one at a time) to the boxes with numbers i + 1, i + 2, i + 3 and so on. If Vasya puts a ball into the box number n, then the next ball goes to box 1, the next one goes to box 2 and so on. He did it until he had no balls left in his hands. It is possible that Vasya puts multiple balls to the same box, and it is also possible that one or more balls will go to the box number i. If i = n, Vasya puts the first ball into the box number 1, then the next ball goes to box 2 and so on.
For example, let's suppose that initially Vasya had four boxes, and the first box had 3 balls, the second one had 2, the third one had 5 and the fourth one had 4 balls. Then, if i = 3, then Vasya will take all five balls out of the third box and put them in the boxes with numbers: 4, 1, 2, 3, 4. After all Vasya's actions the balls will lie in the boxes as follows: in the first box there are 4 balls, 3 in the second one, 1 in the third one and 6 in the fourth one.
At this point Vasya has completely forgotten the original arrangement of the balls in the boxes, but he knows how they are arranged now, and the number x β the number of the box, where he put the last of the taken out balls.
He asks you to help to find the initial arrangement of the balls in the boxes.
Input
The first line of the input contains two integers n and x (2 β€ n β€ 105, 1 β€ x β€ n), that represent the number of the boxes and the index of the box that got the last ball from Vasya, correspondingly. The second line contains n space-separated integers a1, a2, ..., an, where integer ai (0 β€ ai β€ 109, ax β 0) represents the number of balls in the box with index i after Vasya completes all the actions.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use the cin, cout streams or the %I64d specifier.
Output
Print n integers, where the i-th one represents the number of balls in the box number i before Vasya starts acting. Separate the numbers in the output by spaces. If there are multiple correct solutions, you are allowed to print any of them.
Examples
Input
4 4
4 3 1 6
Output
3 2 5 4
Input
5 2
3 2 0 2 7
Output
2 1 4 1 6
Input
3 3
2 3 1
Output
1 2 3
Submitted Solution:
```
n, x = map(int, input().split())
t = list(map(int, input().split()))
m = min(t[: x])
if m == 0:
i = x - 1
while t[i]: i -= 1
t[i + 1: x] = [j - 1 for j in t[i + 1: x]]
t[i] = x - i - 1
else:
t[: x] = [i - 1 for i in t[: x]]
m = min(t)
if m: t = [i - m for i in t]
i = n - 1
while t[i]: i -= 1
t[i + 1: ] = [j - 1 for j in t[i + 1: ]]
t[i] = x + m * n + n - i - 1
print(' '.join(map(str, t)))
``` | instruction | 0 | 18,841 | 8 | 37,682 |
Yes | output | 1 | 18,841 | 8 | 37,683 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little Vasya had n boxes with balls in the room. The boxes stood in a row and were numbered with numbers from 1 to n from left to right.
Once Vasya chose one of the boxes, let's assume that its number is i, took all balls out from it (it is guaranteed that this box originally had at least one ball), and began putting balls (one at a time) to the boxes with numbers i + 1, i + 2, i + 3 and so on. If Vasya puts a ball into the box number n, then the next ball goes to box 1, the next one goes to box 2 and so on. He did it until he had no balls left in his hands. It is possible that Vasya puts multiple balls to the same box, and it is also possible that one or more balls will go to the box number i. If i = n, Vasya puts the first ball into the box number 1, then the next ball goes to box 2 and so on.
For example, let's suppose that initially Vasya had four boxes, and the first box had 3 balls, the second one had 2, the third one had 5 and the fourth one had 4 balls. Then, if i = 3, then Vasya will take all five balls out of the third box and put them in the boxes with numbers: 4, 1, 2, 3, 4. After all Vasya's actions the balls will lie in the boxes as follows: in the first box there are 4 balls, 3 in the second one, 1 in the third one and 6 in the fourth one.
At this point Vasya has completely forgotten the original arrangement of the balls in the boxes, but he knows how they are arranged now, and the number x β the number of the box, where he put the last of the taken out balls.
He asks you to help to find the initial arrangement of the balls in the boxes.
Input
The first line of the input contains two integers n and x (2 β€ n β€ 105, 1 β€ x β€ n), that represent the number of the boxes and the index of the box that got the last ball from Vasya, correspondingly. The second line contains n space-separated integers a1, a2, ..., an, where integer ai (0 β€ ai β€ 109, ax β 0) represents the number of balls in the box with index i after Vasya completes all the actions.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use the cin, cout streams or the %I64d specifier.
Output
Print n integers, where the i-th one represents the number of balls in the box number i before Vasya starts acting. Separate the numbers in the output by spaces. If there are multiple correct solutions, you are allowed to print any of them.
Examples
Input
4 4
4 3 1 6
Output
3 2 5 4
Input
5 2
3 2 0 2 7
Output
2 1 4 1 6
Input
3 3
2 3 1
Output
1 2 3
Submitted Solution:
```
import os
import sys
from io import BytesIO, IOBase
from collections import Counter
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
def gcd(a, b):
if a == 0:
return b
return gcd(b % a, a)
def lcm(a, b):
return (a * b) / gcd(a, b)
def main():
n,x=map(int, input().split())
a=list(map(int , input().split()))
k=min(a)
init=k*n
for i in range(n):
if a[i]==k:
ind=i
break
for i in range(n):
a[i]-=k
store=ind
while(1):
if (a[(x-1+n)%n]==0):
a[(x-1+n)%n]=init
break
x=(x-1+n)%n
a[x]-=1
init+=1
print(*a)
return
if __name__ == "__main__":
main()
``` | instruction | 0 | 18,842 | 8 | 37,684 |
Yes | output | 1 | 18,842 | 8 | 37,685 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little Vasya had n boxes with balls in the room. The boxes stood in a row and were numbered with numbers from 1 to n from left to right.
Once Vasya chose one of the boxes, let's assume that its number is i, took all balls out from it (it is guaranteed that this box originally had at least one ball), and began putting balls (one at a time) to the boxes with numbers i + 1, i + 2, i + 3 and so on. If Vasya puts a ball into the box number n, then the next ball goes to box 1, the next one goes to box 2 and so on. He did it until he had no balls left in his hands. It is possible that Vasya puts multiple balls to the same box, and it is also possible that one or more balls will go to the box number i. If i = n, Vasya puts the first ball into the box number 1, then the next ball goes to box 2 and so on.
For example, let's suppose that initially Vasya had four boxes, and the first box had 3 balls, the second one had 2, the third one had 5 and the fourth one had 4 balls. Then, if i = 3, then Vasya will take all five balls out of the third box and put them in the boxes with numbers: 4, 1, 2, 3, 4. After all Vasya's actions the balls will lie in the boxes as follows: in the first box there are 4 balls, 3 in the second one, 1 in the third one and 6 in the fourth one.
At this point Vasya has completely forgotten the original arrangement of the balls in the boxes, but he knows how they are arranged now, and the number x β the number of the box, where he put the last of the taken out balls.
He asks you to help to find the initial arrangement of the balls in the boxes.
Input
The first line of the input contains two integers n and x (2 β€ n β€ 105, 1 β€ x β€ n), that represent the number of the boxes and the index of the box that got the last ball from Vasya, correspondingly. The second line contains n space-separated integers a1, a2, ..., an, where integer ai (0 β€ ai β€ 109, ax β 0) represents the number of balls in the box with index i after Vasya completes all the actions.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use the cin, cout streams or the %I64d specifier.
Output
Print n integers, where the i-th one represents the number of balls in the box number i before Vasya starts acting. Separate the numbers in the output by spaces. If there are multiple correct solutions, you are allowed to print any of them.
Examples
Input
4 4
4 3 1 6
Output
3 2 5 4
Input
5 2
3 2 0 2 7
Output
2 1 4 1 6
Input
3 3
2 3 1
Output
1 2 3
Submitted Solution:
```
'''input
3 3
2 3 1
'''
from sys import stdin, setrecursionlimit
import math
from collections import defaultdict, deque
setrecursionlimit(15000)
def transform(arr, ans):
for i in range(len(arr)):
arr[i] -= ans
def find_index(x, arr, ):
i = x - 1
while True:
if arr[i] == 0:
break
arr[i] -= 1
i -= 1
if i == -1:
i = n - 1
return i
def add_remain(x, arr, index):
i = x - 1
count = 0
while True:
if i == index:
break
count += 1
i -= 1
if i == -1:
i = len(arr) - 1
return count
# main starts
n, x = list(map(int, stdin.readline().split()))
arr = list(map(int, stdin.readline().split()))
carr = arr[:]
mn = min(arr)
transform(carr, mn)
ans = mn * n
index = find_index(x, carr)
ans += add_remain(x, arr, index)
for i in range(n):
arr[i] -= mn
arr[index] = ans
i = x - 1
while True:
if i == index:
break
arr[i] -= 1
i -= 1
if i < 0:
i = n - 1
print(*arr)
``` | instruction | 0 | 18,843 | 8 | 37,686 |
Yes | output | 1 | 18,843 | 8 | 37,687 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.