Dataset Viewer
lang
stringclasses 1
value | prompt
stringlengths 1.38k
11.2k
| eval_prompt
stringlengths 45
8.05k
| ground_truth
stringlengths 4
163
| unit_tests
stringlengths 57
502
| task_id
stringlengths 23
25
| split
stringclasses 2
values |
|---|---|---|---|---|---|---|
python
|
Complete the code in python to solve this programming problem:
Description: You are given an integer $$$x$$$ and an array of integers $$$a_1, a_2, \ldots, a_n$$$. You have to determine if the number $$$a_1! + a_2! + \ldots + a_n!$$$ is divisible by $$$x!$$$.Here $$$k!$$$ is a factorial of $$$k$$$ — the product of all positive integers less than or equal to $$$k$$$. For example, $$$3! = 1 \cdot 2 \cdot 3 = 6$$$, and $$$5! = 1 \cdot 2 \cdot 3 \cdot 4 \cdot 5 = 120$$$.
Input Specification: The first line contains two integers $$$n$$$ and $$$x$$$ ($$$1 \le n \le 500\,000$$$, $$$1 \le x \le 500\,000$$$). The second line contains $$$n$$$ integers $$$a_1, a_2, \ldots, a_n$$$ ($$$1 \le a_i \le x$$$) — elements of given array.
Output Specification: In the only line print "Yes" (without quotes) if $$$a_1! + a_2! + \ldots + a_n!$$$ is divisible by $$$x!$$$, and "No" (without quotes) otherwise.
Notes: NoteIn the first example $$$3! + 2! + 2! + 2! + 3! + 3! = 6 + 2 + 2 + 2 + 6 + 6 = 24$$$. Number $$$24$$$ is divisible by $$$4! = 24$$$.In the second example $$$3! + 2! + 2! + 2! + 2! + 2! + 1! + 1! = 18$$$, is divisible by $$$3! = 6$$$.In the third example $$$7! + 7! + 7! + 7! + 7! + 7! + 7! = 7 \cdot 7!$$$. It is easy to prove that this number is not divisible by $$$8!$$$.
Code:
def rl():
return [int(i) for i in input().split()]
def solve():
[n,x]=rl()
a=rl()
nax=500000+5
ct=[0 for i in range(nax)]
for b in a:
ct[b]+=1
for i in range(x):
if # TODO: Your code here:
return "No"
ct[i+1]+=ct[i]/(i+1)
return "Yes"
print(solve())
|
def rl():
return [int(i) for i in input().split()]
def solve():
[n,x]=rl()
a=rl()
nax=500000+5
ct=[0 for i in range(nax)]
for b in a:
ct[b]+=1
for i in range(x):
if {{completion}}:
return "No"
ct[i+1]+=ct[i]/(i+1)
return "Yes"
print(solve())
|
ct[i]%(i+1)
|
[{"input": "6 4\n3 2 2 2 3 3", "output": ["Yes"]}, {"input": "8 3\n3 2 2 2 2 2 1 1", "output": ["Yes"]}, {"input": "7 8\n7 7 7 7 7 7 7", "output": ["No"]}, {"input": "10 5\n4 3 2 1 4 3 2 4 3 4", "output": ["No"]}, {"input": "2 500000\n499999 499999", "output": ["No"]}]
|
control_completion_005984
|
control_fixed
|
python
|
Complete the code in python to solve this programming problem:
Description: The derby between Milan and Inter is happening soon, and you have been chosen as the assistant referee for the match, also known as linesman. Your task is to move along the touch-line, namely the side of the field, always looking very carefully at the match to check for offside positions and other offences.Football is an extremely serious matter in Italy, and thus it is fundamental that you keep very close track of the ball for as much time as possible. This means that you want to maximise the number of kicks which you monitor closely. You are able to monitor closely a kick if, when it happens, you are in the position along the touch-line with minimum distance from the place where the kick happens.Fortunately, expert analysts have been able to accurately predict all the kicks which will occur during the game. That is, you have been given two lists of integers, $$$t_1, \ldots, t_n$$$ and $$$a_1, \ldots, a_n$$$, indicating that $$$t_i$$$ seconds after the beginning of the match the ball will be kicked and you can monitor closely such kick if you are at the position $$$a_i$$$ along the touch-line. At the beginning of the game you start at position $$$0$$$ and the maximum speed at which you can walk along the touch-line is $$$v$$$ units per second (i.e., you can change your position by at most $$$v$$$ each second). What is the maximum number of kicks that you can monitor closely?
Input Specification: The first line contains two integers $$$n$$$ and $$$v$$$ ($$$1 \le n \le 2 \cdot 10^5$$$, $$$1 \le v \le 10^6$$$) — the number of kicks that will take place and your maximum speed. The second line contains $$$n$$$ integers $$$t_1, \ldots, t_n$$$ ($$$1 \le t_i \le 10^9$$$) — the times of the kicks in the match. The sequence of times is guaranteed to be strictly increasing, i.e., $$$t_1 < t_2 < \cdots < t_n$$$. The third line contains $$$n$$$ integers $$$a_1, \ldots, a_n$$$ ($$$-10^9 \le a_i \le 10^9$$$) — the positions along the touch-line where you have to be to monitor closely each kick.
Output Specification: Print the maximum number of kicks that you can monitor closely.
Notes: NoteIn the first sample, it is possible to move to the right at maximum speed for the first $$$3.5$$$ seconds and stay at position $$$7$$$ until the first kick happens, and then immediately move right also at maximum speed to watch the second kick at position $$$17$$$. There is no way to monitor closely the third kick after the second kick, so at most $$$2$$$ kicks can be seen.
Code:
from bisect import bisect_right,bisect_left
n,v = map(int,input().split())
t = [*map(int,input().split())]
a = [*map(int,input().split())]
res = []
for i in range(n):
xi,yi = t[i]*v+a[i],t[i]*v-a[i]
if(xi>=0 and yi>=0):
res.append((xi,yi))
res.sort()
dp = [float("inf")]*(n+3)
dp[0] = 0
dp[n+2] = 0
for i in range(len(res)):
pos = bisect_right(dp,res[i][1],0,n+2)
dp[pos] = res[i][1]
for i in range(n,-1,-1):
if(dp[i]!=float("inf")):
# TODO: Your code here
|
from bisect import bisect_right,bisect_left
n,v = map(int,input().split())
t = [*map(int,input().split())]
a = [*map(int,input().split())]
res = []
for i in range(n):
xi,yi = t[i]*v+a[i],t[i]*v-a[i]
if(xi>=0 and yi>=0):
res.append((xi,yi))
res.sort()
dp = [float("inf")]*(n+3)
dp[0] = 0
dp[n+2] = 0
for i in range(len(res)):
pos = bisect_right(dp,res[i][1],0,n+2)
dp[pos] = res[i][1]
for i in range(n,-1,-1):
if(dp[i]!=float("inf")):
{{completion}}
|
print(i)
break
|
[{"input": "3 2\n5 10 15\n7 17 29", "output": ["2"]}, {"input": "5 1\n5 7 8 11 13\n3 3 -2 -2 4", "output": ["3"]}, {"input": "1 2\n3\n7", "output": ["0"]}]
|
block_completion_001106
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: Suppose you have an integer $$$v$$$. In one operation, you can: either set $$$v = (v + 1) \bmod 32768$$$ or set $$$v = (2 \cdot v) \bmod 32768$$$. You are given $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$. What is the minimum number of operations you need to make each $$$a_i$$$ equal to $$$0$$$?
Input Specification: The first line contains the single integer $$$n$$$ ($$$1 \le n \le 32768$$$) — the number of integers. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i < 32768$$$).
Output Specification: Print $$$n$$$ integers. The $$$i$$$-th integer should be equal to the minimum number of operations required to make $$$a_i$$$ equal to $$$0$$$.
Notes: NoteLet's consider each $$$a_i$$$: $$$a_1 = 19$$$. You can, firstly, increase it by one to get $$$20$$$ and then multiply it by two $$$13$$$ times. You'll get $$$0$$$ in $$$1 + 13 = 14$$$ steps. $$$a_2 = 32764$$$. You can increase it by one $$$4$$$ times: $$$32764 \rightarrow 32765 \rightarrow 32766 \rightarrow 32767 \rightarrow 0$$$. $$$a_3 = 10240$$$. You can multiply it by two $$$4$$$ times: $$$10240 \rightarrow 20480 \rightarrow 8192 \rightarrow 16384 \rightarrow 0$$$. $$$a_4 = 49$$$. You can multiply it by two $$$15$$$ times.
Code:
n = int(input())
mod = 1 << 15
for x in map(int, input().split()):
res = 16
for a in range(15):
for b in range(15):
if (x + a) * (1 << b) % mod == 0:
# TODO: Your code here
print(res)
|
n = int(input())
mod = 1 << 15
for x in map(int, input().split()):
res = 16
for a in range(15):
for b in range(15):
if (x + a) * (1 << b) % mod == 0:
{{completion}}
print(res)
|
res = min(res, a + b)
|
[{"input": "4\n19 32764 10240 49", "output": ["14 4 4 15"]}]
|
block_completion_003353
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given an array $$$a$$$ of $$$n$$$ integers. Initially there is only one copy of the given array.You can do operations of two types: Choose any array and clone it. After that there is one more copy of the chosen array. Swap two elements from any two copies (maybe in the same copy) on any positions. You need to find the minimal number of operations needed to obtain a copy where all elements are equal.
Input Specification: The input consists of multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. Description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \le n \le 10^5$$$) — the length of the array $$$a$$$. The second line of each test case contains $$$n$$$ integers $$$a_1, a_2, \ldots, a_n$$$ ($$$-10^9 \le a_i \le 10^9$$$) — the elements of the array $$$a$$$. It is guaranteed that the sum of $$$n$$$ over all test cases does not exceed $$$10^5$$$.
Output Specification: For each test case output a single integer — the minimal number of operations needed to create at least one copy where all elements are equal.
Notes: NoteIn the first test case all elements in the array are already equal, that's why the answer is $$$0$$$.In the second test case it is possible to create a copy of the given array. After that there will be two identical arrays:$$$[ \ 0 \ 1 \ 3 \ 3 \ 7 \ 0 \ ]$$$ and $$$[ \ 0 \ 1 \ 3 \ 3 \ 7 \ 0 \ ]$$$After that we can swap elements in a way so all zeroes are in one array:$$$[ \ 0 \ \underline{0} \ \underline{0} \ 3 \ 7 \ 0 \ ]$$$ and $$$[ \ \underline{1} \ 1 \ 3 \ 3 \ 7 \ \underline{3} \ ]$$$Now let's create a copy of the first array:$$$[ \ 0 \ 0 \ 0 \ 3 \ 7 \ 0 \ ]$$$, $$$[ \ 0 \ 0 \ 0 \ 3 \ 7 \ 0 \ ]$$$ and $$$[ \ 1 \ 1 \ 3 \ 3 \ 7 \ 3 \ ]$$$Let's swap elements in the first two copies:$$$[ \ 0 \ 0 \ 0 \ \underline{0} \ \underline{0} \ 0 \ ]$$$, $$$[ \ \underline{3} \ \underline{7} \ 0 \ 3 \ 7 \ 0 \ ]$$$ and $$$[ \ 1 \ 1 \ 3 \ 3 \ 7 \ 3 \ ]$$$.Finally, we made a copy where all elements are equal and made $$$6$$$ operations.It can be proven that no fewer operations are enough.
Code:
from collections import Counter
for li in[*open(0)][2::2]:
n=len(li:=li.split());
m = max(Counter(li).values())
ans =n-m
while(m<n):
# TODO: Your code here
print(ans)
|
from collections import Counter
for li in[*open(0)][2::2]:
n=len(li:=li.split());
m = max(Counter(li).values())
ans =n-m
while(m<n):
{{completion}}
print(ans)
|
ans+=1
m=2*m
|
[{"input": "6\n1\n1789\n6\n0 1 3 3 7 0\n2\n-1000000000 1000000000\n4\n4 3 2 1\n5\n2 5 7 6 3\n7\n1 1 1 1 1 1 1", "output": ["0\n6\n2\n5\n7\n0"]}]
|
block_completion_004425
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: A ticket is a string consisting of six digits. A ticket is considered lucky if the sum of the first three digits is equal to the sum of the last three digits. Given a ticket, output if it is lucky or not. Note that a ticket can have leading zeroes.
Input Specification: The first line of the input contains an integer $$$t$$$ ($$$1 \leq t \leq 10^3$$$) — the number of testcases. The description of each test consists of one line containing one string consisting of six digits.
Output Specification: Output $$$t$$$ lines, each of which contains the answer to the corresponding test case. Output "YES" if the given ticket is lucky, and "NO" otherwise. You can output the answer in any case (for example, the strings "yEs", "yes", "Yes" and "YES" will be recognized as a positive answer).
Notes: NoteIn the first test case, the sum of the first three digits is $$$2 + 1 + 3 = 6$$$ and the sum of the last three digits is $$$1 + 3 + 2 = 6$$$, they are equal so the answer is "YES".In the second test case, the sum of the first three digits is $$$9 + 7 + 3 = 19$$$ and the sum of the last three digits is $$$8 + 9 + 4 = 21$$$, they are not equal so the answer is "NO".In the third test case, the sum of the first three digits is $$$0 + 4 + 5 = 9$$$ and the sum of the last three digits is $$$2 + 0 + 7 = 9$$$, they are equal so the answer is "YES".
Code:
for # TODO: Your code here:
a = [int(j) for j in input()]
print("YES" if sum(a[0:3])==sum(a[3:6]) else "NO")
|
for {{completion}}:
a = [int(j) for j in input()]
print("YES" if sum(a[0:3])==sum(a[3:6]) else "NO")
|
i in range(int(input()))
|
[{"input": "5\n213132\n973894\n045207\n000000\n055776", "output": ["YES\nNO\nYES\nYES\nNO"]}]
|
control_completion_007491
|
control_fixed
|
python
|
Complete the code in python to solve this programming problem:
Description: Consider a hallway, which can be represented as the matrix with $$$2$$$ rows and $$$n$$$ columns. Let's denote the cell on the intersection of the $$$i$$$-th row and the $$$j$$$-th column as $$$(i, j)$$$. The distance between the cells $$$(i_1, j_1)$$$ and $$$(i_2, j_2)$$$ is $$$|i_1 - i_2| + |j_1 - j_2|$$$.There is a cleaning robot in the cell $$$(1, 1)$$$. Some cells of the hallway are clean, other cells are dirty (the cell with the robot is clean). You want to clean the hallway, so you are going to launch the robot to do this.After the robot is launched, it works as follows. While at least one cell is dirty, the robot chooses the closest (to its current cell) cell among those which are dirty, moves there and cleans it (so the cell is no longer dirty). After cleaning a cell, the robot again finds the closest dirty cell to its current cell, and so on. This process repeats until the whole hallway is clean.However, there is a critical bug in the robot's program. If at some moment, there are multiple closest (to the robot's current position) dirty cells, the robot malfunctions.You want to clean the hallway in such a way that the robot doesn't malfunction. Before launching the robot, you can clean some (possibly zero) of the dirty cells yourself. However, you don't want to do too much dirty work yourself while you have this nice, smart (yet buggy) robot to do this. Note that you cannot make a clean cell dirty.Calculate the maximum possible number of cells you can leave dirty before launching the robot, so that it doesn't malfunction.
Input Specification: The first line contains one integer $$$n$$$ ($$$2 \le n \le 2 \cdot 10^5$$$) — the number of columns in the hallway. Then two lines follow, denoting the $$$1$$$-st and the $$$2$$$-nd row of the hallway. These lines contain $$$n$$$ characters each, where 0 denotes a clean cell and 1 denotes a dirty cell. The starting cell of the robot $$$(1, 1)$$$ is clean.
Output Specification: Print one integer — the maximum possible number of cells you can leave dirty before launching the robot, so that it doesn't malfunction.
Notes: NoteIn the first example, you can clean the cell $$$(1, 2)$$$, so the path of the robot is $$$(1, 1) \rightarrow (2, 1) \rightarrow (2, 2)$$$.In the second example, you can leave the hallway as it is, so the path of the robot is $$$(1, 1) \rightarrow (1, 2) \rightarrow (2, 2)$$$.In the third example, you can clean the cell $$$(1, 2)$$$, so the path of the robot is $$$(1, 1) \rightarrow (2, 1) \rightarrow (2, 3) \rightarrow (2, 4) \rightarrow (1, 4)$$$.In the fourth example, the hallway is already clean. Maybe you have launched the robot earlier?
Code:
import sys
input = lambda: sys.stdin.readline().rstrip()
def solve():
N = int(input())
G = [[int(x) for x in input()] + [0] for _ in range(2)]
dp = [[0] * 2 for _ in range(N + 1)]
for j in range(2):
dp[N - 1][j] = G[1 - j][N - 1]
for i in range(N - 2, - 1, -1):
for j in range(2):
dp[i][j] = G[j][i + 1] + dp[i + 1][j] # can always ignore row 1 - j and proceed right
if G[1 - j][i]:
if # TODO: Your code here:
dp[i][j] = max(dp[i][j], 1 + G[1 - j][i + 1] + G[1 - j][i + 2] + dp[i + 2][1 - j])
else:
dp[i][j] = max(dp[i][j], 1 + G[1 - j][i + 1] + dp[i + 1][1 - j])
print(dp[0][0])
return
solve()
|
import sys
input = lambda: sys.stdin.readline().rstrip()
def solve():
N = int(input())
G = [[int(x) for x in input()] + [0] for _ in range(2)]
dp = [[0] * 2 for _ in range(N + 1)]
for j in range(2):
dp[N - 1][j] = G[1 - j][N - 1]
for i in range(N - 2, - 1, -1):
for j in range(2):
dp[i][j] = G[j][i + 1] + dp[i + 1][j] # can always ignore row 1 - j and proceed right
if G[1 - j][i]:
if {{completion}}:
dp[i][j] = max(dp[i][j], 1 + G[1 - j][i + 1] + G[1 - j][i + 2] + dp[i + 2][1 - j])
else:
dp[i][j] = max(dp[i][j], 1 + G[1 - j][i + 1] + dp[i + 1][1 - j])
print(dp[0][0])
return
solve()
|
G[j][i + 1]
|
[{"input": "2\n01\n11", "output": ["2"]}, {"input": "2\n01\n01", "output": ["2"]}, {"input": "4\n0101\n1011", "output": ["4"]}, {"input": "4\n0000\n0000", "output": ["0"]}, {"input": "5\n00011\n10101", "output": ["4"]}, {"input": "6\n011111\n111111", "output": ["8"]}, {"input": "10\n0101001010\n1010100110", "output": ["6"]}]
|
control_completion_008236
|
control_fixed
|
python
|
Complete the code in python to solve this programming problem:
Description: The store sells $$$n$$$ items, the price of the $$$i$$$-th item is $$$p_i$$$. The store's management is going to hold a promotion: if a customer purchases at least $$$x$$$ items, $$$y$$$ cheapest of them are free.The management has not yet decided on the exact values of $$$x$$$ and $$$y$$$. Therefore, they ask you to process $$$q$$$ queries: for the given values of $$$x$$$ and $$$y$$$, determine the maximum total value of items received for free, if a customer makes one purchase.Note that all queries are independent; they don't affect the store's stock.
Input Specification: The first line contains two integers $$$n$$$ and $$$q$$$ ($$$1 \le n, q \le 2 \cdot 10^5$$$) — the number of items in the store and the number of queries, respectively. The second line contains $$$n$$$ integers $$$p_1, p_2, \dots, p_n$$$ ($$$1 \le p_i \le 10^6$$$), where $$$p_i$$$ — the price of the $$$i$$$-th item. The following $$$q$$$ lines contain two integers $$$x_i$$$ and $$$y_i$$$ each ($$$1 \le y_i \le x_i \le n$$$) — the values of the parameters $$$x$$$ and $$$y$$$ in the $$$i$$$-th query.
Output Specification: For each query, print a single integer — the maximum total value of items received for free for one purchase.
Notes: NoteIn the first query, a customer can buy three items worth $$$5, 3, 5$$$, the two cheapest of them are $$$3 + 5 = 8$$$.In the second query, a customer can buy two items worth $$$5$$$ and $$$5$$$, the cheapest of them is $$$5$$$.In the third query, a customer has to buy all the items to receive the three cheapest of them for free; their total price is $$$1 + 2 + 3 = 6$$$.
Code:
(n, q) = map(int, input().split())
arr = list(map(int, input().split()))
arr.sort(reverse=True)
for i in range (1,n):
arr[i] = arr[i] + arr[i-1]
for trial in range(q):
(x, y) = map(int, input().split())
if (x==y):
print (arr[x-1])
else:
# TODO: Your code here
|
(n, q) = map(int, input().split())
arr = list(map(int, input().split()))
arr.sort(reverse=True)
for i in range (1,n):
arr[i] = arr[i] + arr[i-1]
for trial in range(q):
(x, y) = map(int, input().split())
if (x==y):
print (arr[x-1])
else:
{{completion}}
|
print (arr[x-1] - arr[x-y-1])
|
[{"input": "5 3\n5 3 1 5 2\n3 2\n1 1\n5 3", "output": ["8\n5\n6"]}]
|
block_completion_000523
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: An integer array $$$a_1, a_2, \ldots, a_n$$$ is being transformed into an array of lowercase English letters using the following prodecure:While there is at least one number in the array: Choose any number $$$x$$$ from the array $$$a$$$, and any letter of the English alphabet $$$y$$$. Replace all occurrences of number $$$x$$$ with the letter $$$y$$$. For example, if we initially had an array $$$a = [2, 3, 2, 4, 1]$$$, then we could transform it the following way: Choose the number $$$2$$$ and the letter c. After that $$$a = [c, 3, c, 4, 1]$$$. Choose the number $$$3$$$ and the letter a. After that $$$a = [c, a, c, 4, 1]$$$. Choose the number $$$4$$$ and the letter t. After that $$$a = [c, a, c, t, 1]$$$. Choose the number $$$1$$$ and the letter a. After that $$$a = [c, a, c, t, a]$$$. After the transformation all letters are united into a string, in our example we get the string "cacta".Having the array $$$a$$$ and the string $$$s$$$ determine if the string $$$s$$$ could be got from the array $$$a$$$ after the described transformation?
Input Specification: The first line contains a single integer $$$t$$$ $$$(1 \leq t \leq 10^3$$$) — the number of test cases. Then the description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the length of the array $$$a$$$ and the string $$$s$$$. The second line of each test case contains exactly $$$n$$$ integers: $$$a_1, a_2, \ldots, a_n$$$ ($$$1 \leq a_i \leq 50$$$) — the elements of the array $$$a$$$. The third line of each test case contains a string $$$s$$$ of length $$$n$$$, consisting of lowercase English letters.
Output Specification: For each test case, output "YES", if we can get the string $$$s$$$ from the array $$$a$$$, and "NO" otherwise. You can output each letter in any case.
Notes: NoteThe first test case corresponds to the sample described in the statement.In the second test case we can choose the number $$$50$$$ and the letter a.In the third test case we can choose the number $$$11$$$ and the letter a, after that $$$a = [a, 22]$$$. Then we choose the number $$$22$$$ and the letter b and get $$$a = [a, b]$$$.In the fifth test case we can change all numbers one by one to the letter a.
Code:
from sys import stdin
from collections import deque
lst = stdin.read().split()
_s = 0
def inp(n=1):
global _s
ret = lst[_s:_s + n]
_s += n
return ret
def inp1():
return inp()[0]
t = int(inp1())
for _ in range(t):
n = int(inp1())
a = list(map(int, inp(n)))
s = list(inp1())
d = {}
ok = True
for i in range(n):
if a[i] not in d:
d[a[i]] = s[i]
elif d[a[i]] != s[i]:
# TODO: Your code here
print("YES" if ok else "NO")
|
from sys import stdin
from collections import deque
lst = stdin.read().split()
_s = 0
def inp(n=1):
global _s
ret = lst[_s:_s + n]
_s += n
return ret
def inp1():
return inp()[0]
t = int(inp1())
for _ in range(t):
n = int(inp1())
a = list(map(int, inp(n)))
s = list(inp1())
d = {}
ok = True
for i in range(n):
if a[i] not in d:
d[a[i]] = s[i]
elif d[a[i]] != s[i]:
{{completion}}
print("YES" if ok else "NO")
|
ok = not ok
break
|
[{"input": "7\n\n5\n\n2 3 2 4 1\n\ncacta\n\n1\n\n50\n\na\n\n2\n\n11 22\n\nab\n\n4\n\n1 2 2 1\n\naaab\n\n5\n\n1 2 3 2 1\n\naaaaa\n\n6\n\n1 10 2 9 3 8\n\nazzfdb\n\n7\n\n1 2 3 4 1 1 2\n\nabababb", "output": ["YES\nYES\nYES\nNO\nYES\nYES\nNO"]}]
|
block_completion_004085
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: This is the hard version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the minimum number of contiguous subsegments, and for each subsegment, all bits in each subsegment are the same. After that, $$$s$$$ is considered good if the lengths of all subsegments are even.For example, if $$$s$$$ is "11001111", it will be divided into "11", "00" and "1111". Their lengths are $$$2$$$, $$$2$$$, $$$4$$$ respectively, which are all even numbers, so "11001111" is good. Another example, if $$$s$$$ is "1110011000", it will be divided into "111", "00", "11" and "000", and their lengths are $$$3$$$, $$$2$$$, $$$2$$$, $$$3$$$. Obviously, "1110011000" is not good.Tokitsukaze wants to make $$$s$$$ good by changing the values of some positions in $$$s$$$. Specifically, she can perform the operation any number of times: change the value of $$$s_i$$$ to '0' or '1' ($$$1 \leq i \leq n$$$). Can you tell her the minimum number of operations to make $$$s$$$ good? Meanwhile, she also wants to know the minimum number of subsegments that $$$s$$$ can be divided into among all solutions with the minimum number of operations.
Input Specification: The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones. It is guaranteed that the sum of $$$n$$$ over all test cases does not exceed $$$2 \cdot 10^5$$$.
Output Specification: For each test case, print a single line with two integers — the minimum number of operations to make $$$s$$$ good, and the minimum number of subsegments that $$$s$$$ can be divided into among all solutions with the minimum number of operations.
Notes: NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively, the number of subsegments of it is $$$2$$$. There are other ways to operate $$$3$$$ times to make $$$s$$$ good, such as "1111110000", "1100001100", "1111001100", the number of subsegments of them are $$$2$$$, $$$4$$$, $$$4$$$ respectively. It's easy to find that the minimum number of subsegments among all solutions with the minimum number of operations is $$$2$$$.In the second, third and fourth test cases, $$$s$$$ is good initially, so no operation is required.
Code:
for _ in range(int(input().strip())):
n = int(input().strip())
arr = input()
ans = 0
t = []
for i in range(0, len(arr), 2):
if arr[i] != arr[i + 1]:
ans += 1
else:
# TODO: Your code here
seg = 1
for i in range(0, len(t) - 1):
if t[i] != t[i + 1]:
seg += 1
print(ans, seg)
|
for _ in range(int(input().strip())):
n = int(input().strip())
arr = input()
ans = 0
t = []
for i in range(0, len(arr), 2):
if arr[i] != arr[i + 1]:
ans += 1
else:
{{completion}}
seg = 1
for i in range(0, len(t) - 1):
if t[i] != t[i + 1]:
seg += 1
print(ans, seg)
|
t.append(arr[i])
|
[{"input": "5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110", "output": ["3 2\n0 3\n0 1\n0 1\n3 1"]}]
|
block_completion_008095
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: Suppose you have an integer $$$v$$$. In one operation, you can: either set $$$v = (v + 1) \bmod 32768$$$ or set $$$v = (2 \cdot v) \bmod 32768$$$. You are given $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$. What is the minimum number of operations you need to make each $$$a_i$$$ equal to $$$0$$$?
Input Specification: The first line contains the single integer $$$n$$$ ($$$1 \le n \le 32768$$$) — the number of integers. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$0 \le a_i < 32768$$$).
Output Specification: Print $$$n$$$ integers. The $$$i$$$-th integer should be equal to the minimum number of operations required to make $$$a_i$$$ equal to $$$0$$$.
Notes: NoteLet's consider each $$$a_i$$$: $$$a_1 = 19$$$. You can, firstly, increase it by one to get $$$20$$$ and then multiply it by two $$$13$$$ times. You'll get $$$0$$$ in $$$1 + 13 = 14$$$ steps. $$$a_2 = 32764$$$. You can increase it by one $$$4$$$ times: $$$32764 \rightarrow 32765 \rightarrow 32766 \rightarrow 32767 \rightarrow 0$$$. $$$a_3 = 10240$$$. You can multiply it by two $$$4$$$ times: $$$10240 \rightarrow 20480 \rightarrow 8192 \rightarrow 16384 \rightarrow 0$$$. $$$a_4 = 49$$$. You can multiply it by two $$$15$$$ times.
Code:
n, s = open(0)
for x in map(int, s.split()):
# TODO: Your code here
|
n, s = open(0)
for x in map(int, s.split()):
{{completion}}
|
print(min(15-i+-x % 2**i for i in range(16)))
|
[{"input": "4\n19 32764 10240 49", "output": ["14 4 4 15"]}]
|
block_completion_003354
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: We have an array of length $$$n$$$. Initially, each element is equal to $$$0$$$ and there is a pointer located on the first element.We can do the following two kinds of operations any number of times (possibly zero) in any order: If the pointer is not on the last element, increase the element the pointer is currently on by $$$1$$$. Then move it to the next element. If the pointer is not on the first element, decrease the element the pointer is currently on by $$$1$$$. Then move it to the previous element.But there is one additional rule. After we are done, the pointer has to be on the first element.You are given an array $$$a$$$. Determine whether it's possible to obtain $$$a$$$ after some operations or not.
Input Specification: The first line contains a single integer $$$t$$$ $$$(1\le t\le 1000)$$$ — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ $$$(1\le n\le 2 \cdot 10^5)$$$ — the size of array $$$a$$$. The second line of each test case contains $$$n$$$ integers $$$a_1, a_2, \ldots, a_n$$$ ($$$-10^9 \le a_i \le 10^9$$$) — elements of the array. It is guaranteed that the sum of $$$n$$$ over all test cases doesn't exceed $$$2 \cdot 10^5$$$.
Output Specification: For each test case, print "Yes" (without quotes) if it's possible to obtain $$$a$$$ after some operations, and "No" (without quotes) otherwise. You can output "Yes" and "No" in any case (for example, strings "yEs", "yes" and "Yes" will be recognized as a positive response).
Notes: NoteIn the first test case we can obtain the array after some operations, but the pointer won't be on the first element.One way of obtaining the array in the second test case is shown below.$$$\langle \underline{0}, 0, 0, 0\rangle \to \langle 1, \underline{0}, 0, 0 \rangle \to \langle \underline{1}, -1, 0, 0\rangle \to \langle 2, \underline{-1}, 0, 0\rangle \to \langle 2, 0, \underline{0}, 0\rangle \to \langle 2, \underline{0}, -1, 0\rangle \to \langle \underline{2}, -1, -1, 0\rangle$$$
Code:
from sys import stdin
t = int(stdin.readline())
for h in range(t):
n = int(stdin.readline())
a = list(map(int,stdin.readline().split(' ')))
b = 0
v = True
for i in range(n):
b += a[i]
if b<0:
v = False
break
elif b==0:
for j in range(i+1,n):
if a[j] != 0:
# TODO: Your code here
break
if v and sum(a) == 0:
print('YES')
else:
print('NO')
|
from sys import stdin
t = int(stdin.readline())
for h in range(t):
n = int(stdin.readline())
a = list(map(int,stdin.readline().split(' ')))
b = 0
v = True
for i in range(n):
b += a[i]
if b<0:
v = False
break
elif b==0:
for j in range(i+1,n):
if a[j] != 0:
{{completion}}
break
if v and sum(a) == 0:
print('YES')
else:
print('NO')
|
v = False
break
|
[{"input": "7\n2\n1 0\n4\n2 -1 -1 0\n4\n1 -4 3 0\n4\n1 -1 1 -1\n5\n1 2 3 4 -10\n7\n2 -1 1 -2 0 0 0\n1\n0", "output": ["No\nYes\nNo\nNo\nYes\nYes\nYes"]}]
|
block_completion_000425
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: Let's call a string $$$s$$$ perfectly balanced if for all possible triplets $$$(t,u,v)$$$ such that $$$t$$$ is a non-empty substring of $$$s$$$ and $$$u$$$ and $$$v$$$ are characters present in $$$s$$$, the difference between the frequencies of $$$u$$$ and $$$v$$$ in $$$t$$$ is not more than $$$1$$$.For example, the strings "aba" and "abc" are perfectly balanced but "abb" is not because for the triplet ("bb",'a','b'), the condition is not satisfied.You are given a string $$$s$$$ consisting of lowercase English letters only. Your task is to determine whether $$$s$$$ is perfectly balanced or not.A string $$$b$$$ is called a substring of another string $$$a$$$ if $$$b$$$ can be obtained by deleting some characters (possibly $$$0$$$) from the start and some characters (possibly $$$0$$$) from the end of $$$a$$$.
Input Specification: The first line of input contains a single integer $$$t$$$ ($$$1\leq t\leq 2\cdot 10^4$$$) denoting the number of testcases. Each of the next $$$t$$$ lines contain a single string $$$s$$$ ($$$1\leq |s|\leq 2\cdot 10^5$$$), consisting of lowercase English letters. It is guaranteed that the sum of $$$|s|$$$ over all testcases does not exceed $$$2\cdot 10^5$$$.
Output Specification: For each test case, print "YES" if $$$s$$$ is a perfectly balanced string, and "NO" otherwise. You may print each letter in any case (for example, "YES", "Yes", "yes", "yEs" will all be recognized as positive answer).
Notes: NoteLet $$$f_t(c)$$$ represent the frequency of character $$$c$$$ in string $$$t$$$.For the first testcase we have $$$t$$$$$$f_t(a)$$$$$$f_t(b)$$$$$$a$$$$$$1$$$$$$0$$$$$$ab$$$$$$1$$$$$$1$$$$$$aba$$$$$$2$$$$$$1$$$$$$b$$$$$$0$$$$$$1$$$$$$ba$$$$$$1$$$$$$1$$$ It can be seen that for any substring $$$t$$$ of $$$s$$$, the difference between $$$f_t(a)$$$ and $$$f_t(b)$$$ is not more than $$$1$$$. Hence the string $$$s$$$ is perfectly balanced.For the second testcase we have $$$t$$$$$$f_t(a)$$$$$$f_t(b)$$$$$$a$$$$$$1$$$$$$0$$$$$$ab$$$$$$1$$$$$$1$$$$$$abb$$$$$$1$$$$$$2$$$$$$b$$$$$$0$$$$$$1$$$$$$bb$$$$$$0$$$$$$2$$$ It can be seen that for the substring $$$t=bb$$$, the difference between $$$f_t(a)$$$ and $$$f_t(b)$$$ is $$$2$$$ which is greater than $$$1$$$. Hence the string $$$s$$$ is not perfectly balanced.For the third testcase we have $$$t$$$$$$f_t(a)$$$$$$f_t(b)$$$$$$f_t(c)$$$$$$a$$$$$$1$$$$$$0$$$$$$0$$$$$$ab$$$$$$1$$$$$$1$$$$$$0$$$$$$abc$$$$$$1$$$$$$1$$$$$$1$$$$$$b$$$$$$0$$$$$$1$$$$$$0$$$$$$bc$$$$$$0$$$$$$1$$$$$$1$$$$$$c$$$$$$0$$$$$$0$$$$$$1$$$It can be seen that for any substring $$$t$$$ of $$$s$$$ and any two characters $$$u,v\in\{a,b,c\}$$$, the difference between $$$f_t(u)$$$ and $$$f_t(v)$$$ is not more than $$$1$$$. Hence the string $$$s$$$ is perfectly balanced.
Code:
for # TODO: Your code here:
string=tuple(input().strip())
k=len(set(string))
print("NO" if any([string[i]!=string[i%k] for i in range (len(string))]) else "YES")
|
for {{completion}}:
string=tuple(input().strip())
k=len(set(string))
print("NO" if any([string[i]!=string[i%k] for i in range (len(string))]) else "YES")
|
_ in range(int(input()))
|
[{"input": "5\naba\nabb\nabc\naaaaa\nabcba", "output": ["YES\nNO\nYES\nYES\nNO"]}]
|
control_completion_004715
|
control_fixed
|
python
|
Complete the code in python to solve this programming problem:
Description: The store sells $$$n$$$ items, the price of the $$$i$$$-th item is $$$p_i$$$. The store's management is going to hold a promotion: if a customer purchases at least $$$x$$$ items, $$$y$$$ cheapest of them are free.The management has not yet decided on the exact values of $$$x$$$ and $$$y$$$. Therefore, they ask you to process $$$q$$$ queries: for the given values of $$$x$$$ and $$$y$$$, determine the maximum total value of items received for free, if a customer makes one purchase.Note that all queries are independent; they don't affect the store's stock.
Input Specification: The first line contains two integers $$$n$$$ and $$$q$$$ ($$$1 \le n, q \le 2 \cdot 10^5$$$) — the number of items in the store and the number of queries, respectively. The second line contains $$$n$$$ integers $$$p_1, p_2, \dots, p_n$$$ ($$$1 \le p_i \le 10^6$$$), where $$$p_i$$$ — the price of the $$$i$$$-th item. The following $$$q$$$ lines contain two integers $$$x_i$$$ and $$$y_i$$$ each ($$$1 \le y_i \le x_i \le n$$$) — the values of the parameters $$$x$$$ and $$$y$$$ in the $$$i$$$-th query.
Output Specification: For each query, print a single integer — the maximum total value of items received for free for one purchase.
Notes: NoteIn the first query, a customer can buy three items worth $$$5, 3, 5$$$, the two cheapest of them are $$$3 + 5 = 8$$$.In the second query, a customer can buy two items worth $$$5$$$ and $$$5$$$, the cheapest of them is $$$5$$$.In the third query, a customer has to buy all the items to receive the three cheapest of them for free; their total price is $$$1 + 2 + 3 = 6$$$.
Code:
f=open(0)
R=lambda:map(int,next(f).split())
n,q=R();p=[0]
for w in sorted(R()): p+=p[-1]+w,
for # TODO: Your code here: x, y=R();print(p[n-x+y]-p[n-x])
|
f=open(0)
R=lambda:map(int,next(f).split())
n,q=R();p=[0]
for w in sorted(R()): p+=p[-1]+w,
for {{completion}}: x, y=R();print(p[n-x+y]-p[n-x])
|
_ in " "*q
|
[{"input": "5 3\n5 3 1 5 2\n3 2\n1 1\n5 3", "output": ["8\n5\n6"]}]
|
control_completion_000504
|
control_fixed
|
python
|
Complete the code in python to solve this programming problem:
Description: You are an ambitious king who wants to be the Emperor of The Reals. But to do that, you must first become Emperor of The Integers.Consider a number axis. The capital of your empire is initially at $$$0$$$. There are $$$n$$$ unconquered kingdoms at positions $$$0<x_1<x_2<\ldots<x_n$$$. You want to conquer all other kingdoms.There are two actions available to you: You can change the location of your capital (let its current position be $$$c_1$$$) to any other conquered kingdom (let its position be $$$c_2$$$) at a cost of $$$a\cdot |c_1-c_2|$$$. From the current capital (let its current position be $$$c_1$$$) you can conquer an unconquered kingdom (let its position be $$$c_2$$$) at a cost of $$$b\cdot |c_1-c_2|$$$. You cannot conquer a kingdom if there is an unconquered kingdom between the target and your capital. Note that you cannot place the capital at a point without a kingdom. In other words, at any point, your capital can only be at $$$0$$$ or one of $$$x_1,x_2,\ldots,x_n$$$. Also note that conquering a kingdom does not change the position of your capital.Find the minimum total cost to conquer all kingdoms. Your capital can be anywhere at the end.
Input Specification: The first line contains a single integer $$$t$$$ ($$$1 \le t \le 1000$$$) — the number of test cases. The description of each test case follows. The first line of each test case contains $$$3$$$ integers $$$n$$$, $$$a$$$, and $$$b$$$ ($$$1 \leq n \leq 2 \cdot 10^5$$$; $$$1 \leq a,b \leq 10^5$$$). The second line of each test case contains $$$n$$$ integers $$$x_1, x_2, \ldots, x_n$$$ ($$$1 \leq x_1 < x_2 < \ldots < x_n \leq 10^8$$$). The sum of $$$n$$$ over all test cases does not exceed $$$2 \cdot 10^5$$$.
Output Specification: For each test case, output a single integer — the minimum cost to conquer all kingdoms.
Notes: NoteHere is an optimal sequence of moves for the second test case: Conquer the kingdom at position $$$1$$$ with cost $$$3\cdot(1-0)=3$$$. Move the capital to the kingdom at position $$$1$$$ with cost $$$6\cdot(1-0)=6$$$. Conquer the kingdom at position $$$5$$$ with cost $$$3\cdot(5-1)=12$$$. Move the capital to the kingdom at position $$$5$$$ with cost $$$6\cdot(5-1)=24$$$. Conquer the kingdom at position $$$6$$$ with cost $$$3\cdot(6-5)=3$$$. Conquer the kingdom at position $$$21$$$ with cost $$$3\cdot(21-5)=48$$$. Conquer the kingdom at position $$$30$$$ with cost $$$3\cdot(30-5)=75$$$. The total cost is $$$3+6+12+24+3+48+75=171$$$. You cannot get a lower cost than this.
Code:
for _ in range(int(input())):
n,a,b=map(int, input().split())
w=[int(x) for x in input().split()]
fb=sum(w)*b
fa=0
ans = fb
cap = 0
cur = n
for x in w:
fb -= x * b
cur -= 1
if # TODO: Your code here:
ans += (x - cap) * a
ans -= (x - cap) * cur * b
cap = x
#print(cap)
print(ans)
|
for _ in range(int(input())):
n,a,b=map(int, input().split())
w=[int(x) for x in input().split()]
fb=sum(w)*b
fa=0
ans = fb
cap = 0
cur = n
for x in w:
fb -= x * b
cur -= 1
if {{completion}}:
ans += (x - cap) * a
ans -= (x - cap) * cur * b
cap = x
#print(cap)
print(ans)
|
(x - cap) * a + fb - (x - cap) * cur * b < fb
|
[{"input": "4\n5 2 7\n3 5 12 13 21\n5 6 3\n1 5 6 21 30\n2 9 3\n10 15\n11 27182 31415\n16 18 33 98 874 989 4848 20458 34365 38117 72030", "output": ["173\n171\n75\n3298918744"]}]
|
control_completion_008538
|
control_fixed
|
python
|
Complete the code in python to solve this programming problem:
Description: A ticket is a string consisting of six digits. A ticket is considered lucky if the sum of the first three digits is equal to the sum of the last three digits. Given a ticket, output if it is lucky or not. Note that a ticket can have leading zeroes.
Input Specification: The first line of the input contains an integer $$$t$$$ ($$$1 \leq t \leq 10^3$$$) — the number of testcases. The description of each test consists of one line containing one string consisting of six digits.
Output Specification: Output $$$t$$$ lines, each of which contains the answer to the corresponding test case. Output "YES" if the given ticket is lucky, and "NO" otherwise. You can output the answer in any case (for example, the strings "yEs", "yes", "Yes" and "YES" will be recognized as a positive answer).
Notes: NoteIn the first test case, the sum of the first three digits is $$$2 + 1 + 3 = 6$$$ and the sum of the last three digits is $$$1 + 3 + 2 = 6$$$, they are equal so the answer is "YES".In the second test case, the sum of the first three digits is $$$9 + 7 + 3 = 19$$$ and the sum of the last three digits is $$$8 + 9 + 4 = 21$$$, they are not equal so the answer is "NO".In the third test case, the sum of the first three digits is $$$0 + 4 + 5 = 9$$$ and the sum of the last three digits is $$$2 + 0 + 7 = 9$$$, they are equal so the answer is "YES".
Code:
for c in [input() for i in range(int(input()))]: # TODO: Your code here
|
for c in [input() for i in range(int(input()))]: {{completion}}
|
print(('NO', 'YES')[sum(int(p) for p in (c[:3])) == sum(int(p) for p in (c[3:]))])
|
[{"input": "5\n213132\n973894\n045207\n000000\n055776", "output": ["YES\nNO\nYES\nYES\nNO"]}]
|
block_completion_007622
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You like the card board game "Set". Each card contains $$$k$$$ features, each of which is equal to a value from the set $$$\{0, 1, 2\}$$$. The deck contains all possible variants of cards, that is, there are $$$3^k$$$ different cards in total.A feature for three cards is called good if it is the same for these cards or pairwise distinct. Three cards are called a set if all $$$k$$$ features are good for them.For example, the cards $$$(0, 0, 0)$$$, $$$(0, 2, 1)$$$, and $$$(0, 1, 2)$$$ form a set, but the cards $$$(0, 2, 2)$$$, $$$(2, 1, 2)$$$, and $$$(1, 2, 0)$$$ do not, as, for example, the last feature is not good.A group of five cards is called a meta-set, if there is strictly more than one set among them. How many meta-sets there are among given $$$n$$$ distinct cards?
Input Specification: The first line of the input contains two integers $$$n$$$ and $$$k$$$ ($$$1 \le n \le 10^3$$$, $$$1 \le k \le 20$$$) — the number of cards on a table and the number of card features. The description of the cards follows in the next $$$n$$$ lines. Each line describing a card contains $$$k$$$ integers $$$c_{i, 1}, c_{i, 2}, \ldots, c_{i, k}$$$ ($$$0 \le c_{i, j} \le 2$$$) — card features. It is guaranteed that all cards are distinct.
Output Specification: Output one integer — the number of meta-sets.
Notes: NoteLet's draw the cards indicating the first four features. The first feature will indicate the number of objects on a card: $$$1$$$, $$$2$$$, $$$3$$$. The second one is the color: red, green, purple. The third is the shape: oval, diamond, squiggle. The fourth is filling: open, striped, solid.You can see the first three tests below. For the first two tests, the meta-sets are highlighted.In the first test, the only meta-set is the five cards $$$(0000,\ 0001,\ 0002,\ 0010,\ 0020)$$$. The sets in it are the triples $$$(0000,\ 0001,\ 0002)$$$ and $$$(0000,\ 0010,\ 0020)$$$. Also, a set is the triple $$$(0100,\ 1000,\ 2200)$$$ which does not belong to any meta-set. In the second test, the following groups of five cards are meta-sets: $$$(0000,\ 0001,\ 0002,\ 0010,\ 0020)$$$, $$$(0000,\ 0001,\ 0002,\ 0100,\ 0200)$$$, $$$(0000,\ 0010,\ 0020,\ 0100,\ 0200)$$$. In there third test, there are $$$54$$$ meta-sets.
Code:
n,k=map(int,input().split())
a=[]
d={}
for i in range(n):
a+=[''.join(input().split())]
d[a[-1]]=0
def cal(s,t):
res=""
for i in range(k):
res+=str((9-int(s[i])-int(t[i]))%3)
return res
for i in range(n):
for # TODO: Your code here:
try:
d[cal(a[i],a[j])]+=1
except:
pass
ans=0
for y in d.values():
ans+=(y*(y-1))//2
print(ans)
|
n,k=map(int,input().split())
a=[]
d={}
for i in range(n):
a+=[''.join(input().split())]
d[a[-1]]=0
def cal(s,t):
res=""
for i in range(k):
res+=str((9-int(s[i])-int(t[i]))%3)
return res
for i in range(n):
for {{completion}}:
try:
d[cal(a[i],a[j])]+=1
except:
pass
ans=0
for y in d.values():
ans+=(y*(y-1))//2
print(ans)
|
j in range(i)
|
[{"input": "8 4\n0 0 0 0\n0 0 0 1\n0 0 0 2\n0 0 1 0\n0 0 2 0\n0 1 0 0\n1 0 0 0\n2 2 0 0", "output": ["1"]}, {"input": "7 4\n0 0 0 0\n0 0 0 1\n0 0 0 2\n0 0 1 0\n0 0 2 0\n0 1 0 0\n0 2 0 0", "output": ["3"]}, {"input": "9 2\n0 0\n0 1\n0 2\n1 0\n1 1\n1 2\n2 0\n2 1\n2 2", "output": ["54"]}, {"input": "20 4\n0 2 0 0\n0 2 2 2\n0 2 2 1\n0 2 0 1\n1 2 2 0\n1 2 1 0\n1 2 2 1\n1 2 0 1\n1 1 2 2\n1 1 0 2\n1 1 2 1\n1 1 1 1\n2 1 2 0\n2 1 1 2\n2 1 2 1\n2 1 1 1\n0 1 1 2\n0 0 1 0\n2 2 0 0\n2 0 0 2", "output": ["0"]}]
|
control_completion_005229
|
control_fixed
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given two arrays: an array $$$a$$$ consisting of $$$n$$$ zeros and an array $$$b$$$ consisting of $$$n$$$ integers.You can apply the following operation to the array $$$a$$$ an arbitrary number of times: choose some subsegment of $$$a$$$ of length $$$k$$$ and add the arithmetic progression $$$1, 2, \ldots, k$$$ to this subsegment — i. e. add $$$1$$$ to the first element of the subsegment, $$$2$$$ to the second element, and so on. The chosen subsegment should be inside the borders of the array $$$a$$$ (i.e., if the left border of the chosen subsegment is $$$l$$$, then the condition $$$1 \le l \le l + k - 1 \le n$$$ should be satisfied). Note that the progression added is always $$$1, 2, \ldots, k$$$ but not the $$$k, k - 1, \ldots, 1$$$ or anything else (i.e., the leftmost element of the subsegment always increases by $$$1$$$, the second element always increases by $$$2$$$ and so on).Your task is to find the minimum possible number of operations required to satisfy the condition $$$a_i \ge b_i$$$ for each $$$i$$$ from $$$1$$$ to $$$n$$$. Note that the condition $$$a_i \ge b_i$$$ should be satisfied for all elements at once.
Input Specification: The first line of the input contains two integers $$$n$$$ and $$$k$$$ ($$$1 \le k \le n \le 3 \cdot 10^5$$$) — the number of elements in both arrays and the length of the subsegment, respectively. The second line of the input contains $$$n$$$ integers $$$b_1, b_2, \ldots, b_n$$$ ($$$1 \le b_i \le 10^{12}$$$), where $$$b_i$$$ is the $$$i$$$-th element of the array $$$b$$$.
Output Specification: Print one integer — the minimum possible number of operations required to satisfy the condition $$$a_i \ge b_i$$$ for each $$$i$$$ from $$$1$$$ to $$$n$$$.
Notes: NoteConsider the first example. In this test, we don't really have any choice, so we need to add at least five progressions to make the first element equals $$$5$$$. The array $$$a$$$ becomes $$$[5, 10, 15]$$$.Consider the second example. In this test, let's add one progression on the segment $$$[1; 3]$$$ and two progressions on the segment $$$[4; 6]$$$. Then, the array $$$a$$$ becomes $$$[1, 2, 3, 2, 4, 6]$$$.
Code:
n, k = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
dd = [0]*(len(a)+5)
add = 0
diff = 0
moves = 0
for key, i in reversed([*enumerate(a)]):
add += diff
i += add
diff += dd[-1]
dd.pop()
if i > 0:
# TODO: Your code here
print(moves)
|
n, k = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
dd = [0]*(len(a)+5)
add = 0
diff = 0
moves = 0
for key, i in reversed([*enumerate(a)]):
add += diff
i += add
diff += dd[-1]
dd.pop()
if i > 0:
{{completion}}
print(moves)
|
K = min(k, key+1)
dd[-K] -= (i+K-1)//K
diff += (i+K-1)//K
moves += (i+K-1)//K
add -= K*((i+K-1)//K)
|
[{"input": "3 3\n5 4 6", "output": ["5"]}, {"input": "6 3\n1 2 3 2 2 3", "output": ["3"]}, {"input": "6 3\n1 2 4 1 2 3", "output": ["3"]}, {"input": "7 3\n50 17 81 25 42 39 96", "output": ["92"]}]
|
block_completion_003446
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: Julia's $$$n$$$ friends want to organize a startup in a new country they moved to. They assigned each other numbers from 1 to $$$n$$$ according to the jobs they have, from the most front-end tasks to the most back-end ones. They also estimated a matrix $$$c$$$, where $$$c_{ij} = c_{ji}$$$ is the average number of messages per month between people doing jobs $$$i$$$ and $$$j$$$.Now they want to make a hierarchy tree. It will be a binary tree with each node containing one member of the team. Some member will be selected as a leader of the team and will be contained in the root node. In order for the leader to be able to easily reach any subordinate, for each node $$$v$$$ of the tree, the following should apply: all members in its left subtree must have smaller numbers than $$$v$$$, and all members in its right subtree must have larger numbers than $$$v$$$.After the hierarchy tree is settled, people doing jobs $$$i$$$ and $$$j$$$ will be communicating via the shortest path in the tree between their nodes. Let's denote the length of this path as $$$d_{ij}$$$. Thus, the cost of their communication is $$$c_{ij} \cdot d_{ij}$$$.Your task is to find a hierarchy tree that minimizes the total cost of communication over all pairs: $$$\sum_{1 \le i < j \le n} c_{ij} \cdot d_{ij}$$$.
Input Specification: The first line contains an integer $$$n$$$ ($$$1 \le n \le 200$$$) – the number of team members organizing a startup. The next $$$n$$$ lines contain $$$n$$$ integers each, $$$j$$$-th number in $$$i$$$-th line is $$$c_{ij}$$$ — the estimated number of messages per month between team members $$$i$$$ and $$$j$$$ ($$$0 \le c_{ij} \le 10^9; c_{ij} = c_{ji}; c_{ii} = 0$$$).
Output Specification: Output a description of a hierarchy tree that minimizes the total cost of communication. To do so, for each team member from 1 to $$$n$$$ output the number of the member in its parent node, or 0 for the leader. If there are many optimal trees, output a description of any one of them.
Notes: NoteThe minimal possible total cost is $$$566 \cdot 1+239 \cdot 1+30 \cdot 1+1 \cdot 2+1 \cdot 2=839$$$:
Code:
n=int(input())
c=[]
for _ in range(n):
c.append(tuple(map(int,input().split())))
prefix_sum=[[0]*(n+1) for _ in range(n+1)]
for i in range(1,n+1):
temp=0
for j in range(1,n+1):
temp+=c[i-1][j-1]
prefix_sum[i][j]+=prefix_sum[i-1][j]+temp
def get_rectangel_sum(x1,y1,x2,y2):
return prefix_sum[x2+1][y2+1]-prefix_sum[x1][y2+1]-prefix_sum[x2+1][y1]+prefix_sum[x1][y1]
def cost(x,y):
if x>y:
return 0
a=get_rectangel_sum(x,0,y,x-1) if x!=0 else 0
b=get_rectangel_sum(x,y+1,y,n-1) if y!=n-1 else 0
return a+b
dp=[[float("INF")]*n for _ in range(n)]
best_root_for_range=[[-1]*n for _ in range(n)]
for i in range(n):
dp[i][i]=0
best_root_for_range[i][i]=i
def get_dp_cost(x,y):
return dp[x][y] if x<=y else 0
for length in range(1,n):
# actual length is length+1
for i in range(n-length):
j=i+length
for root in range(i,j+1):
temp=cost(i,root-1)+cost(root+1,j)+get_dp_cost(i,root-1)+get_dp_cost(root+1,j)
if temp<dp[i][j]:
# TODO: Your code here
ans=[-1]*n
def assign_ans(ansecstor,x,y):
if x>y:
return
root=best_root_for_range[x][y]
ans[root]=ansecstor
assign_ans(root,x,root-1)
assign_ans(root,root+1,y)
assign_ans(-1,0,n-1)
print(*[i+1 for i in ans])
# 3
# 0 1 2
# 1 0 3
# 2 3 0
# 4
# 0 1 2 3
# 1 0 5 7
# 2 5 0 4
# 3 7 4 0
# 6
# 0 100 20 37 14 73
# 100 0 17 13 20 2
# 20 17 0 1093 900 1
# 37 13 1093 0 2 4
# 14 20 900 2 0 1
# 73 2 1 4 1 0
|
n=int(input())
c=[]
for _ in range(n):
c.append(tuple(map(int,input().split())))
prefix_sum=[[0]*(n+1) for _ in range(n+1)]
for i in range(1,n+1):
temp=0
for j in range(1,n+1):
temp+=c[i-1][j-1]
prefix_sum[i][j]+=prefix_sum[i-1][j]+temp
def get_rectangel_sum(x1,y1,x2,y2):
return prefix_sum[x2+1][y2+1]-prefix_sum[x1][y2+1]-prefix_sum[x2+1][y1]+prefix_sum[x1][y1]
def cost(x,y):
if x>y:
return 0
a=get_rectangel_sum(x,0,y,x-1) if x!=0 else 0
b=get_rectangel_sum(x,y+1,y,n-1) if y!=n-1 else 0
return a+b
dp=[[float("INF")]*n for _ in range(n)]
best_root_for_range=[[-1]*n for _ in range(n)]
for i in range(n):
dp[i][i]=0
best_root_for_range[i][i]=i
def get_dp_cost(x,y):
return dp[x][y] if x<=y else 0
for length in range(1,n):
# actual length is length+1
for i in range(n-length):
j=i+length
for root in range(i,j+1):
temp=cost(i,root-1)+cost(root+1,j)+get_dp_cost(i,root-1)+get_dp_cost(root+1,j)
if temp<dp[i][j]:
{{completion}}
ans=[-1]*n
def assign_ans(ansecstor,x,y):
if x>y:
return
root=best_root_for_range[x][y]
ans[root]=ansecstor
assign_ans(root,x,root-1)
assign_ans(root,root+1,y)
assign_ans(-1,0,n-1)
print(*[i+1 for i in ans])
# 3
# 0 1 2
# 1 0 3
# 2 3 0
# 4
# 0 1 2 3
# 1 0 5 7
# 2 5 0 4
# 3 7 4 0
# 6
# 0 100 20 37 14 73
# 100 0 17 13 20 2
# 20 17 0 1093 900 1
# 37 13 1093 0 2 4
# 14 20 900 2 0 1
# 73 2 1 4 1 0
|
dp[i][j]=temp
best_root_for_range[i][j]=root
|
[{"input": "4\n0 566 1 0\n566 0 239 30\n1 239 0 1\n0 30 1 0", "output": ["2 4 2 0"]}]
|
block_completion_003210
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given an array of length $$$2^n$$$. The elements of the array are numbered from $$$1$$$ to $$$2^n$$$.You have to process $$$q$$$ queries to this array. In the $$$i$$$-th query, you will be given an integer $$$k$$$ ($$$0 \le k \le n-1$$$). To process the query, you should do the following: for every $$$i \in [1, 2^n-2^k]$$$ in ascending order, do the following: if the $$$i$$$-th element was already swapped with some other element during this query, skip it; otherwise, swap $$$a_i$$$ and $$$a_{i+2^k}$$$; after that, print the maximum sum over all contiguous subsegments of the array (including the empty subsegment). For example, if the array $$$a$$$ is $$$[-3, 5, -3, 2, 8, -20, 6, -1]$$$, and $$$k = 1$$$, the query is processed as follows: the $$$1$$$-st element wasn't swapped yet, so we swap it with the $$$3$$$-rd element; the $$$2$$$-nd element wasn't swapped yet, so we swap it with the $$$4$$$-th element; the $$$3$$$-rd element was swapped already; the $$$4$$$-th element was swapped already; the $$$5$$$-th element wasn't swapped yet, so we swap it with the $$$7$$$-th element; the $$$6$$$-th element wasn't swapped yet, so we swap it with the $$$8$$$-th element. So, the array becomes $$$[-3, 2, -3, 5, 6, -1, 8, -20]$$$. The subsegment with the maximum sum is $$$[5, 6, -1, 8]$$$, and the answer to the query is $$$18$$$.Note that the queries actually change the array, i. e. after a query is performed, the array does not return to its original state, and the next query will be applied to the modified array.
Input Specification: The first line contains one integer $$$n$$$ ($$$1 \le n \le 18$$$). The second line contains $$$2^n$$$ integers $$$a_1, a_2, \dots, a_{2^n}$$$ ($$$-10^9 \le a_i \le 10^9$$$). The third line contains one integer $$$q$$$ ($$$1 \le q \le 2 \cdot 10^5$$$). Then $$$q$$$ lines follow, the $$$i$$$-th of them contains one integer $$$k$$$ ($$$0 \le k \le n-1$$$) describing the $$$i$$$-th query.
Output Specification: For each query, print one integer — the maximum sum over all contiguous subsegments of the array (including the empty subsegment) after processing the query.
Notes: NoteTransformation of the array in the example: $$$[-3, 5, -3, 2, 8, -20, 6, -1] \rightarrow [-3, 2, -3, 5, 6, -1, 8, -20] \rightarrow [2, -3, 5, -3, -1, 6, -20, 8] \rightarrow [5, -3, 2, -3, -20, 8, -1, 6]$$$.
Code:
import sys
input = lambda: sys.stdin.readline().rstrip()
class Node:
def __init__(self, seg, suf, pref, sum) -> None:
self.best = seg
self.suf = suf
self.pref = pref
self.sum = sum
def merge(a, b):
seg = max(a.best, b.best, a.suf + b.pref)
suf = max(b.suf, b.sum + a.suf)
pref = max(a.pref, a.sum + b.pref)
sum = a.sum + b.sum
return Node(seg, suf, pref, sum)
def single(a):
v = max(a, 0)
return Node(v, v, v, a)
def build(v, l, r):
if l + 1 == r:
return [single(A[l])]
else:
m = (l + r) // 2
vl = build(2 * v + 1, l, m)
vr = build(2 * v + 2, m, r)
ans = []
for _ in range(2):
for # TODO: Your code here:
ans.append(merge(vl[i], vr[i]))
vl, vr = vr, vl
return ans
N = int(input())
A = list(map(int, input().split()))
Q = int(input())
M = 1 << N
tree = build(0, 0, M)
curr = 0
for _ in range(Q):
K = int(input())
curr ^= (1 << K)
print(tree[curr].best)
|
import sys
input = lambda: sys.stdin.readline().rstrip()
class Node:
def __init__(self, seg, suf, pref, sum) -> None:
self.best = seg
self.suf = suf
self.pref = pref
self.sum = sum
def merge(a, b):
seg = max(a.best, b.best, a.suf + b.pref)
suf = max(b.suf, b.sum + a.suf)
pref = max(a.pref, a.sum + b.pref)
sum = a.sum + b.sum
return Node(seg, suf, pref, sum)
def single(a):
v = max(a, 0)
return Node(v, v, v, a)
def build(v, l, r):
if l + 1 == r:
return [single(A[l])]
else:
m = (l + r) // 2
vl = build(2 * v + 1, l, m)
vr = build(2 * v + 2, m, r)
ans = []
for _ in range(2):
for {{completion}}:
ans.append(merge(vl[i], vr[i]))
vl, vr = vr, vl
return ans
N = int(input())
A = list(map(int, input().split()))
Q = int(input())
M = 1 << N
tree = build(0, 0, M)
curr = 0
for _ in range(Q):
K = int(input())
curr ^= (1 << K)
print(tree[curr].best)
|
i in range((r - l) // 2)
|
[{"input": "3\n-3 5 -3 2 8 -20 6 -1\n3\n1\n0\n1", "output": ["18\n8\n13"]}]
|
control_completion_008162
|
control_fixed
|
python
|
Complete the code in python to solve this programming problem:
Description: On a beach there are $$$n$$$ huts in a perfect line, hut $$$1$$$ being at the left and hut $$$i+1$$$ being $$$100$$$ meters to the right of hut $$$i$$$, for all $$$1 \le i \le n - 1$$$. In hut $$$i$$$ there are $$$p_i$$$ people.There are $$$m$$$ ice cream sellers, also aligned in a perfect line with all the huts. The $$$i$$$-th ice cream seller has their shop $$$x_i$$$ meters to the right of the first hut. All ice cream shops are at distinct locations, but they may be at the same location as a hut.You want to open a new ice cream shop and you wonder what the best location for your shop is. You can place your ice cream shop anywhere on the beach (not necessarily at an integer distance from the first hut) as long as it is aligned with the huts and the other ice cream shops, even if there is already another ice cream shop or a hut at that location. You know that people would come to your shop only if it is strictly closer to their hut than any other ice cream shop.If every person living in the huts wants to buy exactly one ice cream, what is the maximum number of ice creams that you can sell if you place the shop optimally?
Input Specification: The first line contains two integers $$$n$$$ and $$$m$$$ ($$$2 \le n \le 200\,000$$$, $$$1 \le m \le 200\,000$$$) — the number of huts and the number of ice cream sellers. The second line contains $$$n$$$ integers $$$p_1, p_2, \ldots, p_n$$$ ($$$1 \le p_i \le 10^9$$$) — the number of people in each hut. The third line contains $$$m$$$ integers $$$x_1, x_2, \ldots, x_m$$$ ($$$0 \le x_i \le 10^9$$$, $$$x_i \ne x_j$$$ for $$$i \ne j$$$) — the location of each ice cream shop.
Output Specification: Print the maximum number of ice creams that can be sold by choosing optimally the location of the new shop.
Notes: NoteIn the first sample, you can place the shop (coloured orange in the picture below) $$$150$$$ meters to the right of the first hut (for example) so that it is the closest shop to the first two huts, which have $$$2$$$ and $$$5$$$ people, for a total of $$$7$$$ sold ice creams. In the second sample, you can place the shop $$$170$$$ meters to the right of the first hut (for example) so that it is the closest shop to the last two huts, which have $$$7$$$ and $$$8$$$ people, for a total of $$$15$$$ sold ice creams.
Code:
N, M = [int(x) for x in input().split()]
hut = [int(x) for x in input().split()]
shop = [int(x) for x in input().split()]
shop = sorted([-1e9] + shop + [1e9])
events = []
j = 0
for i in range(N):
while shop[j] < 100*i:
j += 1
if # TODO: Your code here:
d = min(100*i - shop[j-1], shop[j] - 100*i)
events.append((100*i-d, hut[i]))
events.append((100*i+d, -hut[i]))
events.sort()
cont = 0
max = 0
for a in events:
cont += a[1]
if cont > max:
max = cont
print(max)
|
N, M = [int(x) for x in input().split()]
hut = [int(x) for x in input().split()]
shop = [int(x) for x in input().split()]
shop = sorted([-1e9] + shop + [1e9])
events = []
j = 0
for i in range(N):
while shop[j] < 100*i:
j += 1
if {{completion}}:
d = min(100*i - shop[j-1], shop[j] - 100*i)
events.append((100*i-d, hut[i]))
events.append((100*i+d, -hut[i]))
events.sort()
cont = 0
max = 0
for a in events:
cont += a[1]
if cont > max:
max = cont
print(max)
|
shop[j] != 100 * i
|
[{"input": "3 1\n2 5 6\n169", "output": ["7"]}, {"input": "4 2\n1 2 7 8\n35 157", "output": ["15"]}, {"input": "4 1\n272203905 348354708 848256926 939404176\n20", "output": ["2136015810"]}, {"input": "3 2\n1 1 1\n300 99", "output": ["2"]}]
|
control_completion_001129
|
control_fixed
|
python
|
Complete the code in python to solve this programming problem:
Description: $$$m$$$ chairs are arranged in a circle sequentially. The chairs are numbered from $$$0$$$ to $$$m-1$$$. $$$n$$$ people want to sit in these chairs. The $$$i$$$-th of them wants at least $$$a[i]$$$ empty chairs both on his right and left side. More formally, if the $$$i$$$-th person sits in the $$$j$$$-th chair, then no one else should sit in the following chairs: $$$(j-a[i]) \bmod m$$$, $$$(j-a[i]+1) \bmod m$$$, ... $$$(j+a[i]-1) \bmod m$$$, $$$(j+a[i]) \bmod m$$$.Decide if it is possible to sit down for all of them, under the given limitations.
Input Specification: The input consists of multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 5 \cdot 10^4$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains two integers $$$n$$$ and $$$m$$$ ($$$2 \leq n \leq 10^5$$$, $$$1 \leq m \leq 10^9$$$) — the number of people and the number of chairs. The next line contains $$$n$$$ integers, $$$a_1$$$, $$$a_2$$$, ... $$$a_n$$$ ($$$1 \leq a_i \leq 10^9$$$) — the minimum number of empty chairs, on both sides of the $$$i$$$-th person. It is guaranteed that the sum of $$$n$$$ over all test cases will not exceed $$$10^5$$$.
Output Specification: For each test case print "YES" (without quotes) if it is possible for everyone to sit down and fulfil the restrictions, and "NO" (without quotes) otherwise. You may print every letter in any case you want (so, for example, the strings "yEs", "yes", "Yes" and "YES" will all be recognized as positive answers).
Notes: NoteTest case $$$1$$$: $$$n>m$$$, so they can not sit down.Test case $$$2$$$: the first person can sit $$$2$$$-nd and the second person can sit in the $$$0$$$-th chair. Both of them want at least $$$1$$$ empty chair on both sides, chairs $$$1$$$ and $$$3$$$ are free, so this is a good solution.Test case $$$3$$$: if the second person sits down somewhere, he needs $$$2$$$ empty chairs, both on his right and on his left side, so it is impossible to find a place for the first person, because there are only $$$5$$$ chairs.Test case $$$4$$$: they can sit in the $$$1$$$-st, $$$4$$$-th, $$$7$$$-th chairs respectively.
Code:
for T in range (int(input())) :
n,m = map(int, input().strip().split())
a = sorted(list(map(int,input().strip().split())),reverse=True)
m -= 2*a[0] + 1
cont = 0
for i in range(1,n) :
if # TODO: Your code here: break
m -= a[i] + 1
cont +=1
if cont == n-1 : print('YES')
else : print ('NO')
|
for T in range (int(input())) :
n,m = map(int, input().strip().split())
a = sorted(list(map(int,input().strip().split())),reverse=True)
m -= 2*a[0] + 1
cont = 0
for i in range(1,n) :
if {{completion}}: break
m -= a[i] + 1
cont +=1
if cont == n-1 : print('YES')
else : print ('NO')
|
m <= 0
|
[{"input": "6\n3 2\n1 1 1\n2 4\n1 1\n2 5\n2 1\n3 8\n1 2 1\n4 12\n1 2 1 3\n4 19\n1 2 1 3", "output": ["NO\nYES\nNO\nYES\nNO\nYES"]}]
|
control_completion_001003
|
control_fixed
|
python
|
Complete the code in python to solve this programming problem:
Description: There is a grid, consisting of $$$2$$$ rows and $$$m$$$ columns. The rows are numbered from $$$1$$$ to $$$2$$$ from top to bottom. The columns are numbered from $$$1$$$ to $$$m$$$ from left to right.The robot starts in a cell $$$(1, 1)$$$. In one second, it can perform either of two actions: move into a cell adjacent by a side: up, right, down or left; remain in the same cell. The robot is not allowed to move outside the grid.Initially, all cells, except for the cell $$$(1, 1)$$$, are locked. Each cell $$$(i, j)$$$ contains a value $$$a_{i,j}$$$ — the moment that this cell gets unlocked. The robot can only move into a cell $$$(i, j)$$$ if at least $$$a_{i,j}$$$ seconds have passed before the move.The robot should visit all cells without entering any cell twice or more (cell $$$(1, 1)$$$ is considered entered at the start). It can finish in any cell.What is the fastest the robot can achieve that?
Input Specification: The first line contains a single integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of testcases. The first line of each testcase contains a single integer $$$m$$$ ($$$2 \le m \le 2 \cdot 10^5$$$) — the number of columns of the grid. The $$$i$$$-th of the next $$$2$$$ lines contains $$$m$$$ integers $$$a_{i,1}, a_{i,2}, \dots, a_{i,m}$$$ ($$$0 \le a_{i,j} \le 10^9$$$) — the moment of time each cell gets unlocked. $$$a_{1,1} = 0$$$. If $$$a_{i,j} = 0$$$, then cell $$$(i, j)$$$ is unlocked from the start. The sum of $$$m$$$ over all testcases doesn't exceed $$$2 \cdot 10^5$$$.
Output Specification: For each testcase, print a single integer — the minimum amount of seconds that the robot can take to visit all cells without entering any cell twice or more.
Code:
def readline():
line = input()
while not line:
line = input()
return line
def main():
t = int(readline())
for _ in range(t):
m = int(readline())
a = [ [], [] ]
a[0] += list(map(int, readline().split()))
a[1] = list(map(int, readline().split()))
h = [ [None] * m, [None] * m ]
h[0][m-1] = max(a[1][m-1]+1, a[0][m-1]+1+1)
h[1][m-1] = max(a[0][m-1]+1, a[1][m-1]+1+1)
for i in reversed(range(m-1)):
h[0][i] = max(a[1][i]+1, h[0][i+1]+1, a[0][i]+(i!=0)+(m-i-1)*2+1)
h[1][i] = max(a[0][i]+1, h[1][i+1]+1, a[1][i]+1+(m-i-1)*2+1)
pos = (0,0)
t = 0
best_total_time = 10**10
for i in range(2*m-1):
if i % 2 == 0:
total_time = max(t+(m-i//2-1)*2+1, h[pos[0]][pos[1]])
# print(pos, t,total_time)
best_total_time = min(best_total_time, total_time)
if i % 4 == 0:
# abajo
pos = (pos[0]+1, pos[1])
elif # TODO: Your code here:
# derecha
pos = (pos[0], pos[1]+1)
elif (i-2) % 4 == 0:
# arr
pos = (pos[0]-1, pos[1])
elif (i-3) % 4 == 0:
# derecha
pos = (pos[0], pos[1]+1)
t = max(a[pos[0]][pos[1]] + 1, t+1)
# for line in h:
# print(line)
print(best_total_time)
main()
|
def readline():
line = input()
while not line:
line = input()
return line
def main():
t = int(readline())
for _ in range(t):
m = int(readline())
a = [ [], [] ]
a[0] += list(map(int, readline().split()))
a[1] = list(map(int, readline().split()))
h = [ [None] * m, [None] * m ]
h[0][m-1] = max(a[1][m-1]+1, a[0][m-1]+1+1)
h[1][m-1] = max(a[0][m-1]+1, a[1][m-1]+1+1)
for i in reversed(range(m-1)):
h[0][i] = max(a[1][i]+1, h[0][i+1]+1, a[0][i]+(i!=0)+(m-i-1)*2+1)
h[1][i] = max(a[0][i]+1, h[1][i+1]+1, a[1][i]+1+(m-i-1)*2+1)
pos = (0,0)
t = 0
best_total_time = 10**10
for i in range(2*m-1):
if i % 2 == 0:
total_time = max(t+(m-i//2-1)*2+1, h[pos[0]][pos[1]])
# print(pos, t,total_time)
best_total_time = min(best_total_time, total_time)
if i % 4 == 0:
# abajo
pos = (pos[0]+1, pos[1])
elif {{completion}}:
# derecha
pos = (pos[0], pos[1]+1)
elif (i-2) % 4 == 0:
# arr
pos = (pos[0]-1, pos[1])
elif (i-3) % 4 == 0:
# derecha
pos = (pos[0], pos[1]+1)
t = max(a[pos[0]][pos[1]] + 1, t+1)
# for line in h:
# print(line)
print(best_total_time)
main()
|
(i-1) % 4 == 0
|
[{"input": "4\n\n3\n\n0 0 1\n\n4 3 2\n\n5\n\n0 4 8 12 16\n\n2 6 10 14 18\n\n4\n\n0 10 10 10\n\n10 10 10 10\n\n2\n\n0 0\n\n0 0", "output": ["5\n19\n17\n3"]}]
|
control_completion_008132
|
control_fixed
|
python
|
Complete the code in python to solve this programming problem:
Description: Alina has discovered a weird language, which contains only $$$4$$$ words: $$$\texttt{A}$$$, $$$\texttt{B}$$$, $$$\texttt{AB}$$$, $$$\texttt{BA}$$$. It also turned out that there are no spaces in this language: a sentence is written by just concatenating its words into a single string.Alina has found one such sentence $$$s$$$ and she is curious: is it possible that it consists of precisely $$$a$$$ words $$$\texttt{A}$$$, $$$b$$$ words $$$\texttt{B}$$$, $$$c$$$ words $$$\texttt{AB}$$$, and $$$d$$$ words $$$\texttt{BA}$$$?In other words, determine, if it's possible to concatenate these $$$a+b+c+d$$$ words in some order so that the resulting string is $$$s$$$. Each of the $$$a+b+c+d$$$ words must be used exactly once in the concatenation, but you can choose the order in which they are concatenated.
Input Specification: The first line of the input contains a single integer $$$t$$$ ($$$1 \le t \le 10^5$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains four integers $$$a$$$, $$$b$$$, $$$c$$$, $$$d$$$ ($$$0\le a,b,c,d\le 2\cdot 10^5$$$) — the number of times that words $$$\texttt{A}$$$, $$$\texttt{B}$$$, $$$\texttt{AB}$$$, $$$\texttt{BA}$$$ respectively must be used in the sentence. The second line contains the string $$$s$$$ ($$$s$$$ consists only of the characters $$$\texttt{A}$$$ and $$$\texttt{B}$$$, $$$1\le |s| \le 2\cdot 10^5$$$, $$$|s|=a+b+2c+2d$$$) — the sentence. Notice that the condition $$$|s|=a+b+2c+2d$$$ (here $$$|s|$$$ denotes the length of the string $$$s$$$) is equivalent to the fact that $$$s$$$ is as long as the concatenation of the $$$a+b+c+d$$$ words. The sum of the lengths of $$$s$$$ over all test cases doesn't exceed $$$2\cdot 10^5$$$.
Output Specification: For each test case output $$$\texttt{YES}$$$ if it is possible that the sentence $$$s$$$ consists of precisely $$$a$$$ words $$$\texttt{A}$$$, $$$b$$$ words $$$\texttt{B}$$$, $$$c$$$ words $$$\texttt{AB}$$$, and $$$d$$$ words $$$\texttt{BA}$$$, and $$$\texttt{NO}$$$ otherwise. You can output each letter in any case.
Notes: NoteIn the first test case, the sentence $$$s$$$ is $$$\texttt{B}$$$. Clearly, it can't consist of a single word $$$\texttt{A}$$$, so the answer is $$$\texttt{NO}$$$.In the second test case, the sentence $$$s$$$ is $$$\texttt{AB}$$$, and it's possible that it consists of a single word $$$\texttt{AB}$$$, so the answer is $$$\texttt{YES}$$$.In the third test case, the sentence $$$s$$$ is $$$\texttt{ABAB}$$$, and it's possible that it consists of one word $$$\texttt{A}$$$, one word $$$\texttt{B}$$$, and one word $$$\texttt{BA}$$$, as $$$\texttt{A} + \texttt{BA} + \texttt{B} = \texttt{ABAB}$$$.In the fourth test case, the sentence $$$s$$$ is $$$\texttt{ABAAB}$$$, and it's possible that it consists of one word $$$\texttt{A}$$$, one word $$$\texttt{AB}$$$, and one word $$$\texttt{BA}$$$, as $$$\texttt{A} + \texttt{BA} + \texttt{AB} = \texttt{ABAAB}$$$. In the fifth test case, the sentence $$$s$$$ is $$$\texttt{BAABBABBAA}$$$, and it's possible that it consists of one word $$$\texttt{A}$$$, one word $$$\texttt{B}$$$, two words $$$\texttt{AB}$$$, and two words $$$\texttt{BA}$$$, as $$$\texttt{BA} + \texttt{AB} + \texttt{B} + \texttt{AB} + \texttt{BA} + \texttt{A}= \texttt{BAABBABBAA}$$$.
Code:
def canmake(s,a,b,c,d):
anum = s.count('A')
bnum = s.count('B')
cnum = s.count('AB')
dnum = s.count('BA')
if cnum < c or dnum < d or anum != a + c + d or bnum != b + c + d:
return False
n=len(s)
ans=0
abls=[]
bals=[]
l=0
while l<n:
while l<n-1 and s[l]==s[l+1]:
l+=1
r=l
while # TODO: Your code here:
r+=1
if s[l]== s[r]=='B':
ans+=(r-l+1)//2
if s[l]==s[r]=='A':
ans+=(r-l+1)//2
if s[l]=='A' and s[r]=='B':
abls.append((r-l+1)//2)
if s[l]=='B' and s[r]=='A':
bals.append((r-l+1)//2)
l=r+1
abls.sort()
bals.sort()
for i in abls:
if i<=c:
c-=i
else:
d-=i-c-1
c = 0
for i in bals:
if i<=d:
d-=i
else:
c-=i-d-1
d = 0
return (c+d)<=ans
t=int(input())
for _ in range(t):
a,b,c,d=[int(x) for x in input().split()]
s=input()
res=canmake(s,a,b,c,d)
if res:
print('YES')
else:
print('NO')
|
def canmake(s,a,b,c,d):
anum = s.count('A')
bnum = s.count('B')
cnum = s.count('AB')
dnum = s.count('BA')
if cnum < c or dnum < d or anum != a + c + d or bnum != b + c + d:
return False
n=len(s)
ans=0
abls=[]
bals=[]
l=0
while l<n:
while l<n-1 and s[l]==s[l+1]:
l+=1
r=l
while {{completion}}:
r+=1
if s[l]== s[r]=='B':
ans+=(r-l+1)//2
if s[l]==s[r]=='A':
ans+=(r-l+1)//2
if s[l]=='A' and s[r]=='B':
abls.append((r-l+1)//2)
if s[l]=='B' and s[r]=='A':
bals.append((r-l+1)//2)
l=r+1
abls.sort()
bals.sort()
for i in abls:
if i<=c:
c-=i
else:
d-=i-c-1
c = 0
for i in bals:
if i<=d:
d-=i
else:
c-=i-d-1
d = 0
return (c+d)<=ans
t=int(input())
for _ in range(t):
a,b,c,d=[int(x) for x in input().split()]
s=input()
res=canmake(s,a,b,c,d)
if res:
print('YES')
else:
print('NO')
|
r<n-1 and s[r]!=s[r+1]
|
[{"input": "8\n1 0 0 0\nB\n0 0 1 0\nAB\n1 1 0 1\nABAB\n1 0 1 1\nABAAB\n1 1 2 2\nBAABBABBAA\n1 1 2 3\nABABABBAABAB\n2 3 5 4\nAABAABBABAAABABBABBBABB\n1 3 3 10\nBBABABABABBBABABABABABABAABABA", "output": ["NO\nYES\nYES\nYES\nYES\nYES\nNO\nYES"]}]
|
control_completion_001183
|
control_fixed
|
python
|
Complete the code in python to solve this programming problem:
Description: This is the hard version of this problem. In this version, we have queries. Note that we do not have multiple test cases in this version. You can make hacks only if both versions of the problem are solved.An array $$$b$$$ of length $$$m$$$ is good if for all $$$i$$$ the $$$i$$$-th element is greater than or equal to $$$i$$$. In other words, $$$b$$$ is good if and only if $$$b_i \geq i$$$ for all $$$i$$$ ($$$1 \leq i \leq m$$$).You are given an array $$$a$$$ consisting of $$$n$$$ positive integers, and you are asked $$$q$$$ queries. In each query, you are given two integers $$$p$$$ and $$$x$$$ ($$$1 \leq p,x \leq n$$$). You have to do $$$a_p := x$$$ (assign $$$x$$$ to $$$a_p$$$). In the updated array, find the number of pairs of indices $$$(l, r)$$$, where $$$1 \le l \le r \le n$$$, such that the array $$$[a_l, a_{l+1}, \ldots, a_r]$$$ is good.Note that all queries are independent, which means after each query, the initial array $$$a$$$ is restored.
Input Specification: The first line contains a single integer $$$n$$$ ($$$1 \le n \le 2 \cdot 10^5$$$). The second line contains $$$n$$$ integers $$$a_1, a_2, \ldots, a_n$$$ ($$$1 \le a_i \le n$$$). The third line contains an integer $$$q$$$ ($$$1 \leq q \leq 2 \cdot 10^5$$$) — the number of queries. Each of the next $$$q$$$ lines contains two integers $$$p_j$$$ and $$$x_j$$$ ($$$1 \leq p_j, x_j \leq n$$$) – the description of the $$$j$$$-th query.
Output Specification: For each query, print the number of suitable pairs of indices after making the change.
Notes: NoteHere are notes for first example.In first query, after update $$$a=[2,4,1,4]$$$. Now $$$(1,1)$$$, $$$(2,2)$$$, $$$(3,3)$$$, $$$(4,4)$$$, $$$(1,2)$$$, and $$$(3,4)$$$ are suitable pairs.In second query, after update $$$a=[2,4,3,4]$$$. Now all subarrays of $$$a$$$ are good.In third query, after update $$$a=[2,1,1,4]$$$. Now $$$(1,1)$$$, $$$(2,2)$$$, $$$(3,3)$$$, $$$(4,4)$$$, and $$$(3,4)$$$ are suitable.
Code:
from sys import stdin, stdout
from collections import defaultdict
n = int(stdin.readline())
a = [int(x) for x in stdin.readline().split()]
left = 0
right = 0
right_array = []
right_prefix = [0]
answer = 0
second_right = 0
second_right_array = []
second_right_prefix = [0]
while left < n:
if right < left:
right = left
while right < n and a[right] >= right-left+1:
right += 1
right_array.append(right)
right_prefix.append(right_prefix[-1]+right_array[-1])
answer += right - left
if second_right <= right:
second_right = right + 1
if second_right > n:
second_right = n
while second_right < n and a[second_right] >= second_right-left+1:
second_right += 1
second_right_array.append(second_right)
second_right_prefix.append(second_right_prefix[-1]+second_right_array[-1])
left += 1
p_to_right = defaultdict(list)
for i in range(n):
p_to_right[right_array[i]].append(i)
q = int(stdin.readline())
for _ in range(q):
p, x = [int(z) for z in stdin.readline().split()]
p -= 1
if x == a[p]:
adjustment = 0
elif x < a[p]:
if right_array[-1] <= p:
adjustment = 0
else:
upper = n-1
lower = -1
while upper - lower > 1:
candidate = (upper + lower)//2
if right_array[candidate] > p:
upper = candidate
else:
# TODO: Your code here
if upper > p-x:
adjustment = 0
else:
adjustment = -(right_prefix[p-x+1] - right_prefix[upper] - p*(p-x-upper+1))
else:
if len(p_to_right[p]) == 0:
adjustment = 0
elif p_to_right[p][0] > p-a[p] or p_to_right[p][-1] < p-x+1:
adjustment = 0
else:
lower = max(p-x+1, p_to_right[p][0])
upper = min(p-a[p], p_to_right[p][-1])
adjustment = second_right_prefix[upper+1] - second_right_prefix[lower] - p*(upper-lower+1)
stdout.write(str(answer+adjustment)+'\n')
|
from sys import stdin, stdout
from collections import defaultdict
n = int(stdin.readline())
a = [int(x) for x in stdin.readline().split()]
left = 0
right = 0
right_array = []
right_prefix = [0]
answer = 0
second_right = 0
second_right_array = []
second_right_prefix = [0]
while left < n:
if right < left:
right = left
while right < n and a[right] >= right-left+1:
right += 1
right_array.append(right)
right_prefix.append(right_prefix[-1]+right_array[-1])
answer += right - left
if second_right <= right:
second_right = right + 1
if second_right > n:
second_right = n
while second_right < n and a[second_right] >= second_right-left+1:
second_right += 1
second_right_array.append(second_right)
second_right_prefix.append(second_right_prefix[-1]+second_right_array[-1])
left += 1
p_to_right = defaultdict(list)
for i in range(n):
p_to_right[right_array[i]].append(i)
q = int(stdin.readline())
for _ in range(q):
p, x = [int(z) for z in stdin.readline().split()]
p -= 1
if x == a[p]:
adjustment = 0
elif x < a[p]:
if right_array[-1] <= p:
adjustment = 0
else:
upper = n-1
lower = -1
while upper - lower > 1:
candidate = (upper + lower)//2
if right_array[candidate] > p:
upper = candidate
else:
{{completion}}
if upper > p-x:
adjustment = 0
else:
adjustment = -(right_prefix[p-x+1] - right_prefix[upper] - p*(p-x-upper+1))
else:
if len(p_to_right[p]) == 0:
adjustment = 0
elif p_to_right[p][0] > p-a[p] or p_to_right[p][-1] < p-x+1:
adjustment = 0
else:
lower = max(p-x+1, p_to_right[p][0])
upper = min(p-a[p], p_to_right[p][-1])
adjustment = second_right_prefix[upper+1] - second_right_prefix[lower] - p*(upper-lower+1)
stdout.write(str(answer+adjustment)+'\n')
|
lower = candidate
|
[{"input": "4\n2 4 1 4\n3\n2 4\n3 3\n2 1", "output": ["6\n10\n5"]}, {"input": "5\n1 1 3 2 1\n3\n1 3\n2 5\n4 5", "output": ["7\n9\n8"]}]
|
block_completion_007068
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given an array $$$a$$$ consisting of $$$n$$$ integers. You should divide $$$a$$$ into continuous non-empty subarrays (there are $$$2^{n-1}$$$ ways to do that).Let $$$s=a_l+a_{l+1}+\ldots+a_r$$$. The value of a subarray $$$a_l, a_{l+1}, \ldots, a_r$$$ is: $$$(r-l+1)$$$ if $$$s>0$$$, $$$0$$$ if $$$s=0$$$, $$$-(r-l+1)$$$ if $$$s<0$$$. What is the maximum sum of values you can get with a partition?
Input Specification: The input consists of multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \le t \le 5 \cdot 10^5$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \le n \le 5 \cdot 10^5$$$). The second line of each test case contains $$$n$$$ integers $$$a_1$$$, $$$a_2$$$, ..., $$$a_n$$$ ($$$-10^9 \le a_i \le 10^9$$$). It is guaranteed that the sum of $$$n$$$ over all test cases does not exceed $$$5 \cdot 10^5$$$.
Output Specification: For each test case print a single integer — the maximum sum of values you can get with an optimal parition.
Notes: NoteTest case $$$1$$$: one optimal partition is $$$[1, 2]$$$, $$$[-3]$$$. $$$1+2>0$$$ so the value of $$$[1, 2]$$$ is $$$2$$$. $$$-3<0$$$, so the value of $$$[-3]$$$ is $$$-1$$$. $$$2+(-1)=1$$$.Test case $$$2$$$: the optimal partition is $$$[0, -2, 3]$$$, $$$[-4]$$$, and the sum of values is $$$3+(-1)=2$$$.
Code:
from collections import Counter, defaultdict, deque
import bisect
from sys import stdin, stdout
from itertools import repeat
import math
MOD = 998244353
input = stdin.readline
finp = [int(x) for x in stdin.buffer.read().split()]
def inp(force_list=False):
re = list(map(int, input().split()))
if len(re) == 1 and not force_list:
return re[0]
return re
def inst():
return input().strip()
def gcd(x, y):
while(y):
x, y = y, x % y
return x
def qmod(a, b, mod=MOD):
res = 1
while b:
if b&1:
res = (res*a)%mod
b >>= 1
a = (a*a)%mod
return res
def inv(a):
return qmod(a, MOD-2)
INF = 1<<30
class Seg(object):
def __init__(self, n):
self._da = [-INF] * (n * 5)
self._op = [-INF] * (n * 5)
def update(self, p):
self._op[p] = max(self._op[p*2], self._op[p*2+1])
def modify(self, pos, x, p, l, r):
if l==r-1:
self._da[p] = self._op[p] = x
return
mid = (l+r)//2
if pos < mid:
self.modify(pos, x, p*2, l, mid)
else:
# TODO: Your code here
self.update(p)
def query(self, x, y, p, l, r):
if x <= l and r <= y:
return self._op[p]
if x >= r or y<=l:
return -INF
mid = (l+r)//2
return max(self.query(x, y, p*2, l, mid), self.query(x, y, p*2+1, mid, r))
class Fenwick(object):
def __init__(self, n):
self._da = [-INF] * (n+2)
self._mx = n+2
def max(self, x):
res = -INF
while x>0:
res = max(res, self._da[x])
x = (x&(x+1))-1
return res
def modify(self, p, x):
while p < self._mx:
self._da[p] = max(self._da[p], x)
p |= p+1
def my_main():
# print(500000)
# for i in range(500000):
# print(1)
# print(-1000000000)
ii = 0
kase = finp[ii];ii+=1
pans = []
for skase in range(kase):
# print("Case #%d: " % (skase+1), end='')
n = finp[ii];ii+=1
da = finp[ii:ii+n];ii+=n
pref = [0]
for i in da:
pref.append(pref[-1] + i)
spos, sneg = sorted([(pref[i], -i) for i, v in enumerate(pref)]), sorted([(pref[i], i) for i, v in enumerate(pref)])
ordpos, ordneg = [0] * (n+1), [0] * (n+1)
pfen, nfen = Fenwick(n), Fenwick(n)
dmx = {}
for i in range(n+1):
ordpos[-spos[i][-1]] = i
ordneg[sneg[i][-1]] = i
dp = [0] * (n+1)
dmx[0] = 0
pfen.modify(ordpos[0], 0)
nfen.modify(n+1-ordneg[0], 0)
for i in range(1, n+1):
dp[i] = max(i+pfen.max(ordpos[i]), nfen.max(n+1-ordneg[i])-i, dmx.get(pref[i], -INF))
pfen.modify(ordpos[i], dp[i]-i)
nfen.modify(n+1-ordneg[i], dp[i]+i)
if dp[i] > dmx.get(pref[i], -INF):
dmx[pref[i]] = dp[i]
pans.append(str(dp[n]))
print('\n'.join(pans))
my_main()
|
from collections import Counter, defaultdict, deque
import bisect
from sys import stdin, stdout
from itertools import repeat
import math
MOD = 998244353
input = stdin.readline
finp = [int(x) for x in stdin.buffer.read().split()]
def inp(force_list=False):
re = list(map(int, input().split()))
if len(re) == 1 and not force_list:
return re[0]
return re
def inst():
return input().strip()
def gcd(x, y):
while(y):
x, y = y, x % y
return x
def qmod(a, b, mod=MOD):
res = 1
while b:
if b&1:
res = (res*a)%mod
b >>= 1
a = (a*a)%mod
return res
def inv(a):
return qmod(a, MOD-2)
INF = 1<<30
class Seg(object):
def __init__(self, n):
self._da = [-INF] * (n * 5)
self._op = [-INF] * (n * 5)
def update(self, p):
self._op[p] = max(self._op[p*2], self._op[p*2+1])
def modify(self, pos, x, p, l, r):
if l==r-1:
self._da[p] = self._op[p] = x
return
mid = (l+r)//2
if pos < mid:
self.modify(pos, x, p*2, l, mid)
else:
{{completion}}
self.update(p)
def query(self, x, y, p, l, r):
if x <= l and r <= y:
return self._op[p]
if x >= r or y<=l:
return -INF
mid = (l+r)//2
return max(self.query(x, y, p*2, l, mid), self.query(x, y, p*2+1, mid, r))
class Fenwick(object):
def __init__(self, n):
self._da = [-INF] * (n+2)
self._mx = n+2
def max(self, x):
res = -INF
while x>0:
res = max(res, self._da[x])
x = (x&(x+1))-1
return res
def modify(self, p, x):
while p < self._mx:
self._da[p] = max(self._da[p], x)
p |= p+1
def my_main():
# print(500000)
# for i in range(500000):
# print(1)
# print(-1000000000)
ii = 0
kase = finp[ii];ii+=1
pans = []
for skase in range(kase):
# print("Case #%d: " % (skase+1), end='')
n = finp[ii];ii+=1
da = finp[ii:ii+n];ii+=n
pref = [0]
for i in da:
pref.append(pref[-1] + i)
spos, sneg = sorted([(pref[i], -i) for i, v in enumerate(pref)]), sorted([(pref[i], i) for i, v in enumerate(pref)])
ordpos, ordneg = [0] * (n+1), [0] * (n+1)
pfen, nfen = Fenwick(n), Fenwick(n)
dmx = {}
for i in range(n+1):
ordpos[-spos[i][-1]] = i
ordneg[sneg[i][-1]] = i
dp = [0] * (n+1)
dmx[0] = 0
pfen.modify(ordpos[0], 0)
nfen.modify(n+1-ordneg[0], 0)
for i in range(1, n+1):
dp[i] = max(i+pfen.max(ordpos[i]), nfen.max(n+1-ordneg[i])-i, dmx.get(pref[i], -INF))
pfen.modify(ordpos[i], dp[i]-i)
nfen.modify(n+1-ordneg[i], dp[i]+i)
if dp[i] > dmx.get(pref[i], -INF):
dmx[pref[i]] = dp[i]
pans.append(str(dp[n]))
print('\n'.join(pans))
my_main()
|
self.modify(pos, x, p*2 + 1, mid, r)
|
[{"input": "5\n\n3\n\n1 2 -3\n\n4\n\n0 -2 3 -4\n\n5\n\n-1 -2 3 -1 -1\n\n6\n\n-1 2 -3 4 -5 6\n\n7\n\n1 -1 -1 1 -1 -1 1", "output": ["1\n2\n1\n6\n-1"]}]
|
block_completion_001050
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: There are $$$n+1$$$ teleporters on a straight line, located in points $$$0$$$, $$$a_1$$$, $$$a_2$$$, $$$a_3$$$, ..., $$$a_n$$$. It's possible to teleport from point $$$x$$$ to point $$$y$$$ if there are teleporters in both of those points, and it costs $$$(x-y)^2$$$ energy.You want to install some additional teleporters so that it is possible to get from the point $$$0$$$ to the point $$$a_n$$$ (possibly through some other teleporters) spending no more than $$$m$$$ energy in total. Each teleporter you install must be located in an integer point.What is the minimum number of teleporters you have to install?
Input Specification: The first line contains one integer $$$n$$$ ($$$1 \le n \le 2 \cdot 10^5$$$). The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$1 \le a_1 < a_2 < a_3 < \dots < a_n \le 10^9$$$). The third line contains one integer $$$m$$$ ($$$a_n \le m \le 10^{18}$$$).
Output Specification: Print one integer — the minimum number of teleporters you have to install so that it is possible to get from $$$0$$$ to $$$a_n$$$ spending at most $$$m$$$ energy. It can be shown that it's always possible under the constraints from the input format.
Code:
from collections import Counter
n, a, m = int(input()), [*map(int, input().split())], int(input())
def energy(l, t):
x,y = divmod(l, t+1)
return x*x*(t+1-y)+(x+1)*(x+1)*y
def getdiff(l, diff):
lo, hi = 0, l
while lo < hi:
mid = lo + hi >> 1
if energy(l, mid) - energy(l, mid+1) < diff: hi = mid
else: # TODO: Your code here
return lo, energy(l, lo)
def getsum(d, c=0): a1,a2 = zip(*[getdiff(i, d) for i,_ in a]); return (0 if c else sum(a1[i]*x for i, (_, x) in enumerate(a)), sum(a2[i]*x for i, (_, x) in enumerate(a)))
a = [0] + a
a = Counter([a[i+1]-a[i] for i in range(n)]).items()
lo, hi = 1, m
while lo < hi:
mid = lo + hi >> 1
if getsum(mid, 1)[1] > m: hi = mid
else: lo = mid + 1
lo-=1
a1, a2 = getsum(lo)
print(a1-(m-a2)//lo if lo else a1)
|
from collections import Counter
n, a, m = int(input()), [*map(int, input().split())], int(input())
def energy(l, t):
x,y = divmod(l, t+1)
return x*x*(t+1-y)+(x+1)*(x+1)*y
def getdiff(l, diff):
lo, hi = 0, l
while lo < hi:
mid = lo + hi >> 1
if energy(l, mid) - energy(l, mid+1) < diff: hi = mid
else: {{completion}}
return lo, energy(l, lo)
def getsum(d, c=0): a1,a2 = zip(*[getdiff(i, d) for i,_ in a]); return (0 if c else sum(a1[i]*x for i, (_, x) in enumerate(a)), sum(a2[i]*x for i, (_, x) in enumerate(a)))
a = [0] + a
a = Counter([a[i+1]-a[i] for i in range(n)]).items()
lo, hi = 1, m
while lo < hi:
mid = lo + hi >> 1
if getsum(mid, 1)[1] > m: hi = mid
else: lo = mid + 1
lo-=1
a1, a2 = getsum(lo)
print(a1-(m-a2)//lo if lo else a1)
|
lo = mid + 1
|
[{"input": "2\n1 5\n7", "output": ["2"]}, {"input": "2\n1 5\n6", "output": ["3"]}, {"input": "1\n5\n5", "output": ["4"]}, {"input": "1\n1000000000\n1000000043", "output": ["999999978"]}]
|
block_completion_003462
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given a string $$$s$$$ consisting of $$$n$$$ characters. Each character of $$$s$$$ is either 0 or 1.A substring of $$$s$$$ is a contiguous subsequence of its characters.You have to choose two substrings of $$$s$$$ (possibly intersecting, possibly the same, possibly non-intersecting — just any two substrings). After choosing them, you calculate the value of the chosen pair of substrings as follows: let $$$s_1$$$ be the first substring, $$$s_2$$$ be the second chosen substring, and $$$f(s_i)$$$ be the integer such that $$$s_i$$$ is its binary representation (for example, if $$$s_i$$$ is 11010, $$$f(s_i) = 26$$$); the value is the bitwise OR of $$$f(s_1)$$$ and $$$f(s_2)$$$. Calculate the maximum possible value you can get, and print it in binary representation without leading zeroes.
Input Specification: The first line contains one integer $$$n$$$ — the number of characters in $$$s$$$. The second line contains $$$s$$$ itself, consisting of exactly $$$n$$$ characters 0 and/or 1. All non-example tests in this problem are generated randomly: every character of $$$s$$$ is chosen independently of other characters; for each character, the probability of it being 1 is exactly $$$\frac{1}{2}$$$. This problem has exactly $$$40$$$ tests. Tests from $$$1$$$ to $$$3$$$ are the examples; tests from $$$4$$$ to $$$40$$$ are generated randomly. In tests from $$$4$$$ to $$$10$$$, $$$n = 5$$$; in tests from $$$11$$$ to $$$20$$$, $$$n = 1000$$$; in tests from $$$21$$$ to $$$40$$$, $$$n = 10^6$$$. Hacks are forbidden in this problem.
Output Specification: Print the maximum possible value you can get in binary representation without leading zeroes.
Notes: NoteIn the first example, you can choose the substrings 11010 and 101. $$$f(s_1) = 26$$$, $$$f(s_2) = 5$$$, their bitwise OR is $$$31$$$, and the binary representation of $$$31$$$ is 11111.In the second example, you can choose the substrings 1110010 and 11100.
Code:
n = input()
s = int(input(),2)
res = 0
for i in range(100):
# TODO: Your code here
ans = bin(res)[2:]
print(ans)
|
n = input()
s = int(input(),2)
res = 0
for i in range(100):
{{completion}}
ans = bin(res)[2:]
print(ans)
|
res = max(res,(s | (s >> i)))
|
[{"input": "5\n11010", "output": ["11111"]}, {"input": "7\n1110010", "output": ["1111110"]}, {"input": "4\n0000", "output": ["0"]}]
|
block_completion_002157
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: A class of students got bored wearing the same pair of shoes every day, so they decided to shuffle their shoes among themselves. In this problem, a pair of shoes is inseparable and is considered as a single object.There are $$$n$$$ students in the class, and you are given an array $$$s$$$ in non-decreasing order, where $$$s_i$$$ is the shoe size of the $$$i$$$-th student. A shuffling of shoes is valid only if no student gets their own shoes and if every student gets shoes of size greater than or equal to their size. You have to output a permutation $$$p$$$ of $$$\{1,2,\ldots,n\}$$$ denoting a valid shuffling of shoes, where the $$$i$$$-th student gets the shoes of the $$$p_i$$$-th student ($$$p_i \ne i$$$). And output $$$-1$$$ if a valid shuffling does not exist.A permutation is an array consisting of $$$n$$$ distinct integers from $$$1$$$ to $$$n$$$ in arbitrary order. For example, $$$[2,3,1,5,4]$$$ is a permutation, but $$$[1,2,2]$$$ is not a permutation ($$$2$$$ appears twice in the array) and $$$[1,3,4]$$$ is also not a permutation ($$$n=3$$$ but there is $$$4$$$ in the array).
Input Specification: Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \le t \le 1000$$$) — the number of test cases. Description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1\leq n\leq10^5$$$) — the number of students. The second line of each test case contains $$$n$$$ integers $$$s_1, s_2,\ldots,s_n$$$ ($$$1\leq s_i\leq10^9$$$, and for all $$$1\le i<n$$$, $$$s_i\le s_{i+1}$$$) — the shoe sizes of the students. It is guaranteed that the sum of $$$n$$$ over all test cases does not exceed $$$10^5$$$.
Output Specification: For each test case, print the answer in a single line using the following format. If a valid shuffling does not exist, print the number $$$-1$$$ as the answer. If a valid shuffling exists, print $$$n$$$ space-separated integers — a permutation $$$p$$$ of $$$1,2,\ldots,n$$$ denoting a valid shuffling of shoes where the $$$i$$$-th student gets the shoes of the $$$p_i$$$-th student. If there are multiple answers, then print any of them.
Notes: NoteIn the first test case, any permutation $$$p$$$ of $$$1,\ldots,n$$$ where $$$p_i\ne i$$$ would represent a valid shuffling since all students have equal shoe sizes, and thus anyone can wear anyone's shoes.In the second test case, it can be shown that no valid shuffling is possible.
Code:
import collections
import sys
input = sys.stdin.readline
for _ in range(int(input())):
n = int(input())
data = dict(collections.Counter(map(int, input().split())))
if min(list(data.values())) > 1:
last = 1
for i in data.keys():
print(last + data[i] - 1, end=' ')
for j in range(last, last + data[i] - 1):
# TODO: Your code here
last = last + data[i]
print()
else:
print(-1)
|
import collections
import sys
input = sys.stdin.readline
for _ in range(int(input())):
n = int(input())
data = dict(collections.Counter(map(int, input().split())))
if min(list(data.values())) > 1:
last = 1
for i in data.keys():
print(last + data[i] - 1, end=' ')
for j in range(last, last + data[i] - 1):
{{completion}}
last = last + data[i]
print()
else:
print(-1)
|
print(j, end=' ')
|
[{"input": "2\n5\n1 1 1 1 1\n6\n3 6 8 13 15 21", "output": ["5 1 2 3 4 \n-1"]}]
|
block_completion_002398
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: This is a hard version of the problem. The only difference between an easy and a hard version is in the number of queries.Polycarp grew a tree from $$$n$$$ vertices. We remind you that a tree of $$$n$$$ vertices is an undirected connected graph of $$$n$$$ vertices and $$$n-1$$$ edges that does not contain cycles.He calls a set of vertices passable if there is such a path in the tree that passes through each vertex of this set without passing through any edge twice. The path can visit other vertices (not from this set).In other words, a set of vertices is called passable if there is a simple path that passes through all the vertices of this set (and possibly some other).For example, for a tree below sets $$$\{3, 2, 5\}$$$, $$$\{1, 5, 4\}$$$, $$$\{1, 4\}$$$ are passable, and $$$\{1, 3, 5\}$$$, $$$\{1, 2, 3, 4, 5\}$$$ are not. Polycarp asks you to answer $$$q$$$ queries. Each query is a set of vertices. For each query, you need to determine whether the corresponding set of vertices is passable.
Input Specification: The first line of input contains a single integer $$$n$$$ ($$$1 \le n \le 2 \cdot 10^5$$$) — number of vertices. Following $$$n - 1$$$ lines a description of the tree.. Each line contains two integers $$$u$$$ and $$$v$$$ ($$$1 \le u, v \le n$$$, $$$u \ne v$$$) — indices of vertices connected by an edge. Following line contains single integer $$$q$$$ ($$$1 \le q \le 10^5$$$) — number of queries. The following $$$2 \cdot q$$$ lines contain descriptions of sets. The first line of the description contains an integer $$$k$$$ ($$$1 \le k \le n$$$) — the size of the set. The second line of the description contains $$$k$$$ of distinct integers $$$p_1, p_2, \dots, p_k$$$ ($$$1 \le p_i \le n$$$) — indices of the vertices of the set. It is guaranteed that the sum of $$$k$$$ values for all queries does not exceed $$$2 \cdot 10^5$$$.
Output Specification: Output $$$q$$$ lines, each of which contains the answer to the corresponding query. As an answer, output "YES" if the set is passable, and "NO" otherwise. You can output the answer in any case (for example, the strings "yEs", "yes", "Yes" and "YES" will be recognized as a positive answer).
Code:
input = __import__('sys').stdin.readline
mapnode = lambda x: int(x)-1
n = int(input())
adj = [[] for _ in range(n)]
for _ in range(n-1):
u, v = map(mapnode, input().split())
adj[u].append(v)
adj[v].append(u)
# dfs
jump = [[0] * n]
depth = [0] * n
stack = [(0, -1)]
while len(stack) > 0:
u, par = stack.pop()
jump[0][u] = par
for v in adj[u]:
if v != par:
# TODO: Your code here
for _ in range(19):
jump.append([jump[-1][jump[-1][u]] for u in range(n)])
# print('depth', depth)
# print('jump', jump)
def lca(u, v):
if depth[u] < depth[v]:
u, v = v, u
step = depth[u] - depth[v]
for i in range(19):
if (step >> i) & 1 == 1:
u = jump[i][u]
if u == v:
return u
# move up together
for i in range(18, -1, -1):
if jump[i][u] != jump[i][v]:
u, v = jump[i][u], jump[i][v]
return jump[0][u]
# answer queries
for _ in range(int(input())):
nk = int(input())
nodes = list(sorted(map(mapnode, input().split()), key=lambda u: -depth[u]))
mindepth = min(depth[u] for u in nodes)
# check from lowest depth
tocheck = [nodes[i] for i in range(1, nk) if nodes[i] != lca(nodes[0], nodes[i])]
# print(subroot+1, [x+1 for x in tocheck], [x+1 for x in nodes])
ok = len(tocheck) == 0 or all(lca(tocheck[0], u) == u for u in tocheck) and depth[lca(tocheck[0], nodes[0])] <= mindepth
print('YES' if ok else 'NO')
|
input = __import__('sys').stdin.readline
mapnode = lambda x: int(x)-1
n = int(input())
adj = [[] for _ in range(n)]
for _ in range(n-1):
u, v = map(mapnode, input().split())
adj[u].append(v)
adj[v].append(u)
# dfs
jump = [[0] * n]
depth = [0] * n
stack = [(0, -1)]
while len(stack) > 0:
u, par = stack.pop()
jump[0][u] = par
for v in adj[u]:
if v != par:
{{completion}}
for _ in range(19):
jump.append([jump[-1][jump[-1][u]] for u in range(n)])
# print('depth', depth)
# print('jump', jump)
def lca(u, v):
if depth[u] < depth[v]:
u, v = v, u
step = depth[u] - depth[v]
for i in range(19):
if (step >> i) & 1 == 1:
u = jump[i][u]
if u == v:
return u
# move up together
for i in range(18, -1, -1):
if jump[i][u] != jump[i][v]:
u, v = jump[i][u], jump[i][v]
return jump[0][u]
# answer queries
for _ in range(int(input())):
nk = int(input())
nodes = list(sorted(map(mapnode, input().split()), key=lambda u: -depth[u]))
mindepth = min(depth[u] for u in nodes)
# check from lowest depth
tocheck = [nodes[i] for i in range(1, nk) if nodes[i] != lca(nodes[0], nodes[i])]
# print(subroot+1, [x+1 for x in tocheck], [x+1 for x in nodes])
ok = len(tocheck) == 0 or all(lca(tocheck[0], u) == u for u in tocheck) and depth[lca(tocheck[0], nodes[0])] <= mindepth
print('YES' if ok else 'NO')
|
depth[v] = depth[u] + 1
stack.append((v, u))
|
[{"input": "5\n1 2\n2 3\n2 4\n4 5\n5\n3\n3 2 5\n5\n1 2 3 4 5\n2\n1 4\n3\n1 3 5\n3\n1 5 4", "output": ["YES\nNO\nYES\nNO\nYES"]}, {"input": "5\n1 2\n3 2\n2 4\n5 2\n4\n2\n3 1\n3\n3 4 5\n3\n2 3 5\n1\n1", "output": ["YES\nNO\nYES\nYES"]}]
|
block_completion_002280
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: On an $$$8 \times 8$$$ grid, some horizontal rows have been painted red, and some vertical columns have been painted blue, in some order. The stripes are drawn sequentially, one after the other. When the stripe is drawn, it repaints all the cells through which it passes.Determine which color was used last. The red stripe was painted after the blue one, so the answer is R.
Input Specification: The first line of the input contains a single integer $$$t$$$ ($$$1 \leq t \leq 4000$$$) — the number of test cases. The description of test cases follows. There is an empty line before each test case. Each test case consists of $$$8$$$ lines, each containing $$$8$$$ characters. Each of these characters is either 'R', 'B', or '.', denoting a red square, a blue square, and an unpainted square, respectively. It is guaranteed that the given field is obtained from a colorless one by drawing horizontal red rows and vertical blue columns. At least one stripe is painted.
Output Specification: For each test case, output 'R' if a red stripe was painted last, and 'B' if a blue stripe was painted last (without quotes).
Notes: NoteThe first test case is pictured in the statement.In the second test case, the first blue column is painted first, then the first and last red rows, and finally the last blue column. Since a blue stripe is painted last, the answer is B.
Code:
test = int(input())
for i in range(test):
ans = "B"
cnt =0
while cnt < 8 :
t = input()
if t.strip() != '':
cnt +=1
if t == "RRRRRRRR":
# TODO: Your code here
print(ans)
|
test = int(input())
for i in range(test):
ans = "B"
cnt =0
while cnt < 8 :
t = input()
if t.strip() != '':
cnt +=1
if t == "RRRRRRRR":
{{completion}}
print(ans)
|
ans = "R"
|
[{"input": "4\n\n\n\n\n....B...\n\n....B...\n\n....B...\n\nRRRRRRRR\n\n....B...\n\n....B...\n\n....B...\n\n....B...\n\n\n\n\nRRRRRRRB\n\nB......B\n\nB......B\n\nB......B\n\nB......B\n\nB......B\n\nB......B\n\nRRRRRRRB\n\n\n\n\nRRRRRRBB\n\n.B.B..BB\n\nRRRRRRBB\n\n.B.B..BB\n\n.B.B..BB\n\nRRRRRRBB\n\n.B.B..BB\n\n.B.B..BB\n\n\n\n\n........\n\n........\n\n........\n\nRRRRRRRR\n\n........\n\n........\n\n........\n\n........", "output": ["R\nB\nB\nR"]}]
|
block_completion_005800
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: Team Red and Team Blue competed in a competitive FPS. Their match was streamed around the world. They played a series of $$$n$$$ matches.In the end, it turned out Team Red won $$$r$$$ times and Team Blue won $$$b$$$ times. Team Blue was less skilled than Team Red, so $$$b$$$ was strictly less than $$$r$$$.You missed the stream since you overslept, but you think that the match must have been neck and neck since so many people watched it. So you imagine a string of length $$$n$$$ where the $$$i$$$-th character denotes who won the $$$i$$$-th match — it is R if Team Red won or B if Team Blue won. You imagine the string was such that the maximum number of times a team won in a row was as small as possible. For example, in the series of matches RBBRRRB, Team Red won $$$3$$$ times in a row, which is the maximum.You must find a string satisfying the above conditions. If there are multiple answers, print any.
Input Specification: The first line contains a single integer $$$t$$$ ($$$1 \le t \le 1000$$$) — the number of test cases. Each test case has a single line containing three integers $$$n$$$, $$$r$$$, and $$$b$$$ ($$$3 \leq n \leq 100$$$; $$$1 \leq b < r \leq n$$$, $$$r+b=n$$$).
Output Specification: For each test case, output a single line containing a string satisfying the given conditions. If there are multiple answers, print any.
Notes: NoteThe first test case of the first example gives the optimal answer for the example in the statement. The maximum number of times a team wins in a row in RBRBRBR is $$$1$$$. We cannot minimize it any further.The answer for the second test case of the second example is RRBRBRBRBR. The maximum number of times a team wins in a row is $$$2$$$, given by RR at the beginning. We cannot minimize the answer any further.
Code:
t = int(input())
for i in range(t):
x = input().split()
r = int(x[1])
b = int(x[2])
x = ""
p = r%(b+1)
q = r//(b+1)
for i in range(p):
# TODO: Your code here
for i in range(b+1-p):
x+= "R"*(q)+"B"
print(x[:-1])
|
t = int(input())
for i in range(t):
x = input().split()
r = int(x[1])
b = int(x[2])
x = ""
p = r%(b+1)
q = r//(b+1)
for i in range(p):
{{completion}}
for i in range(b+1-p):
x+= "R"*(q)+"B"
print(x[:-1])
|
x += "R"*(q+1)+"B"
|
[{"input": "3\n7 4 3\n6 5 1\n19 13 6", "output": ["RBRBRBR\nRRRBRR\nRRBRRBRRBRRBRRBRRBR"]}, {"input": "6\n3 2 1\n10 6 4\n11 6 5\n10 9 1\n10 8 2\n11 9 2", "output": ["RBR\nRRBRBRBRBR\nRBRBRBRBRBR\nRRRRRBRRRR\nRRRBRRRBRR\nRRRBRRRBRRR"]}]
|
block_completion_008717
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: Given $$$n$$$ strings, each of length $$$2$$$, consisting of lowercase Latin alphabet letters from 'a' to 'k', output the number of pairs of indices $$$(i, j)$$$ such that $$$i < j$$$ and the $$$i$$$-th string and the $$$j$$$-th string differ in exactly one position.In other words, count the number of pairs $$$(i, j)$$$ ($$$i < j$$$) such that the $$$i$$$-th string and the $$$j$$$-th string have exactly one position $$$p$$$ ($$$1 \leq p \leq 2$$$) such that $$${s_{i}}_{p} \neq {s_{j}}_{p}$$$.The answer may not fit into 32-bit integer type, so you should use 64-bit integers like long long in C++ to avoid integer overflow.
Input Specification: The first line of the input contains a single integer $$$t$$$ ($$$1 \le t \le 100$$$) — the number of test cases. The description of test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \le n \le 10^5$$$) — the number of strings. Then follows $$$n$$$ lines, the $$$i$$$-th of which containing a single string $$$s_i$$$ of length $$$2$$$, consisting of lowercase Latin letters from 'a' to 'k'. It is guaranteed that the sum of $$$n$$$ over all test cases does not exceed $$$10^5$$$.
Output Specification: For each test case, print a single integer — the number of pairs $$$(i, j)$$$ ($$$i < j$$$) such that the $$$i$$$-th string and the $$$j$$$-th string have exactly one position $$$p$$$ ($$$1 \leq p \leq 2$$$) such that $$${s_{i}}_{p} \neq {s_{j}}_{p}$$$. Please note, that the answer for some test cases won't fit into 32-bit integer type, so you should use at least 64-bit integer type in your programming language (like long long for C++).
Notes: NoteFor the first test case the pairs that differ in exactly one position are: ("ab", "cb"), ("ab", "db"), ("ab", "aa"), ("cb", "db") and ("cb", "cc").For the second test case the pairs that differ in exactly one position are: ("aa", "ac"), ("aa", "ca"), ("cc", "ac"), ("cc", "ca"), ("ac", "aa") and ("ca", "aa").For the third test case, the are no pairs satisfying the conditions.
Code:
from collections import Counter
t=int(input())
while(t!=0):
n=int(input())
s = Counter(input() for x in [1]*n)
cnt = 0
for x in s:
for y in s:
if(x!=y and (x[1]==y[1] or x[0]==y[0])): # TODO: Your code here
print(cnt//2)
t-=1
|
from collections import Counter
t=int(input())
while(t!=0):
n=int(input())
s = Counter(input() for x in [1]*n)
cnt = 0
for x in s:
for y in s:
if(x!=y and (x[1]==y[1] or x[0]==y[0])): {{completion}}
print(cnt//2)
t-=1
|
cnt += s[x]*s[y]
|
[{"input": "4\n6\nab\ncb\ndb\naa\ncc\nef\n7\naa\nbb\ncc\nac\nca\nbb\naa\n4\nkk\nkk\nab\nab\n5\njf\njf\njk\njk\njk", "output": ["5\n6\n0\n6"]}]
|
block_completion_000893
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given an array $$$a$$$ of $$$n$$$ integers $$$a_1, a_2, a_3, \ldots, a_n$$$.You have to answer $$$q$$$ independent queries, each consisting of two integers $$$l$$$ and $$$r$$$. Consider the subarray $$$a[l:r]$$$ $$$=$$$ $$$[a_l, a_{l+1}, \ldots, a_r]$$$. You can apply the following operation to the subarray any number of times (possibly zero)- Choose two integers $$$L$$$, $$$R$$$ such that $$$l \le L \le R \le r$$$ and $$$R - L + 1$$$ is odd. Replace each element in the subarray from $$$L$$$ to $$$R$$$ with the XOR of the elements in the subarray $$$[L, R]$$$. The answer to the query is the minimum number of operations required to make all elements of the subarray $$$a[l:r]$$$ equal to $$$0$$$ or $$$-1$$$ if it is impossible to make all of them equal to $$$0$$$. You can find more details about XOR operation here.
Input Specification: The first line contains two integers $$$n$$$ and $$$q$$$ $$$(1 \le n, q \le 2 \cdot 10^5)$$$ — the length of the array $$$a$$$ and the number of queries. The next line contains $$$n$$$ integers $$$a_1, a_2, \ldots, a_n$$$ $$$(0 \le a_i \lt 2^{30})$$$ — the elements of the array $$$a$$$. The $$$i$$$-th of the next $$$q$$$ lines contains two integers $$$l_i$$$ and $$$r_i$$$ $$$(1 \le l_i \le r_i \le n)$$$ — the description of the $$$i$$$-th query.
Output Specification: For each query, output a single integer — the answer to that query.
Notes: NoteIn the first query, $$$l = 3, r = 4$$$, subarray = $$$[3, 3]$$$. We can apply operation only to the subarrays of length $$$1$$$, which won't change the array; hence it is impossible to make all elements equal to $$$0$$$.In the second query, $$$l = 4, r = 6$$$, subarray = $$$[3, 1, 2]$$$. We can choose the whole subarray $$$(L = 4, R = 6)$$$ and replace all elements by their XOR $$$(3 \oplus 1 \oplus 2) = 0$$$, making the subarray $$$[0, 0, 0]$$$.In the fifth query, $$$l = 1, r = 6$$$, subarray = $$$[3, 0, 3, 3, 1, 2]$$$. We can make the operations as follows: Choose $$$L = 4, R = 6$$$, making the subarray $$$[3, 0, 3, 0, 0, 0]$$$. Choose $$$L = 1, R = 5$$$, making the subarray $$$[0, 0, 0, 0, 0, 0]$$$.
Code:
import sys
input = sys.stdin.readline
n,q = map(int,input().split())
a = [0] + list(map(int,input().split()))
cml = a[::1]
for i in range(1, n+1):
a[i] ^= a[i-1]
cml[i] += cml[i-1]
qs = [list(map(int,input().split())) for i in range(q)]
from collections import defaultdict
d = defaultdict(list)
dd = defaultdict(list)
cnt = defaultdict(int)
ord = [0]*(n+1)
for i in range(n+1):
dd[a[i]].append(i % 2)
cnt[a[i]] += 1
ord[i] = cnt[a[i]]
for k,v in dd.items():
dd[k] = [0] + v
for i in range(len(v)+1):
if i == 0: continue
else:
dd[k][i] += dd[k][i-1]
for l,r in qs:
if a[r] != a[l-1]:
print(-1)
else:
if cml[r] - cml[l-1] == 0:
print(0)
elif (r-l) % 2 == 0 or a[l] == a[l-1] or a[r] == a[r-1]:
print(1)
else:
ll = ord[l-1]-1
rr = ord[r]
tot = dd[a[r]][rr] - dd[a[r]][ll]
if # TODO: Your code here:
print(-1)
else:
print(2)
|
import sys
input = sys.stdin.readline
n,q = map(int,input().split())
a = [0] + list(map(int,input().split()))
cml = a[::1]
for i in range(1, n+1):
a[i] ^= a[i-1]
cml[i] += cml[i-1]
qs = [list(map(int,input().split())) for i in range(q)]
from collections import defaultdict
d = defaultdict(list)
dd = defaultdict(list)
cnt = defaultdict(int)
ord = [0]*(n+1)
for i in range(n+1):
dd[a[i]].append(i % 2)
cnt[a[i]] += 1
ord[i] = cnt[a[i]]
for k,v in dd.items():
dd[k] = [0] + v
for i in range(len(v)+1):
if i == 0: continue
else:
dd[k][i] += dd[k][i-1]
for l,r in qs:
if a[r] != a[l-1]:
print(-1)
else:
if cml[r] - cml[l-1] == 0:
print(0)
elif (r-l) % 2 == 0 or a[l] == a[l-1] or a[r] == a[r-1]:
print(1)
else:
ll = ord[l-1]-1
rr = ord[r]
tot = dd[a[r]][rr] - dd[a[r]][ll]
if {{completion}}:
print(-1)
else:
print(2)
|
tot == rr-ll or tot == 0
|
[{"input": "7 6\n3 0 3 3 1 2 3\n3 4\n4 6\n3 7\n5 6\n1 6\n2 2", "output": ["-1\n1\n1\n-1\n2\n0"]}]
|
control_completion_001769
|
control_fixed
|
python
|
Complete the code in python to solve this programming problem:
Description: There is a grid, consisting of $$$n$$$ rows and $$$m$$$ columns. The rows are numbered from $$$1$$$ to $$$n$$$ from bottom to top. The columns are numbered from $$$1$$$ to $$$m$$$ from left to right. The $$$i$$$-th column has the bottom $$$a_i$$$ cells blocked (the cells in rows $$$1, 2, \dots, a_i$$$), the remaining $$$n - a_i$$$ cells are unblocked.A robot is travelling across this grid. You can send it commands — move up, right, down or left. If a robot attempts to move into a blocked cell or outside the grid, it explodes.However, the robot is broken — it executes each received command $$$k$$$ times. So if you tell it to move up, for example, it will move up $$$k$$$ times ($$$k$$$ cells). You can't send it commands while the robot executes the current one.You are asked $$$q$$$ queries about the robot. Each query has a start cell, a finish cell and a value $$$k$$$. Can you send the robot an arbitrary number of commands (possibly, zero) so that it reaches the finish cell from the start cell, given that it executes each command $$$k$$$ times?The robot must stop in the finish cell. If it visits the finish cell while still executing commands, it doesn't count.
Input Specification: The first line contains two integers $$$n$$$ and $$$m$$$ ($$$1 \le n \le 10^9$$$; $$$1 \le m \le 2 \cdot 10^5$$$) — the number of rows and columns of the grid. The second line contains $$$m$$$ integers $$$a_1, a_2, \dots, a_m$$$ ($$$0 \le a_i \le n$$$) — the number of blocked cells on the bottom of the $$$i$$$-th column. The third line contains a single integer $$$q$$$ ($$$1 \le q \le 2 \cdot 10^5$$$) — the number of queries. Each of the next $$$q$$$ lines contain five integers $$$x_s, y_s, x_f, y_f$$$ and $$$k$$$ ($$$a[y_s] < x_s \le n$$$; $$$1 \le y_s \le m$$$; $$$a[y_f] < x_f \le n$$$; $$$1 \le y_f \le m$$$; $$$1 \le k \le 10^9$$$) — the row and the column of the start cell, the row and the column of the finish cell and the number of times each your command is executed. The start and the finish cell of each query are unblocked.
Output Specification: For each query, print "YES" if you can send the robot an arbitrary number of commands (possibly, zero) so that it reaches the finish cell from the start cell, given that it executes each command $$$k$$$ times. Otherwise, print "NO".
Code:
import math,sys;input=sys.stdin.readline;S=lambda:input().rstrip();I=lambda:int(S());M=lambda:map(int,S().split());L=lambda:list(M());mod1=1000000007;mod2=998244353
n,m=M();a=L();q=I()
t=[0]*(2*m)
# a is the array of initial values
def build(t,n,a):
for i in range(n):t[i+n]=a[i]
for i in range(n-1,0,-1):t[i]=max(t[i<<1],t[(i<<1)|1])
# change value at position p to v
def modify(t,n,p,v):
p+=n
t[p]=v
while p>1:
t[p>>1]=max(t[p],t[p^1])
p>>=1
# find the combined value of range [l,r)
def query(t,n,l,r):
resl=resr=0
l+=n;r+=n
while l<r:
if (l&1):# TODO: Your code here
if (r&1):r-=1;resr=max(t[r],resr)
l>>=1;r>>=1
return max(resl,resr)
build(t,m,a)
for i in range(q):
xs,ys,xf,yf,k=M()
if abs(xs-xf)%k or abs(ys-yf)%k:print("NO");continue
p=query(t,m,min(ys,yf)-1,max(ys,yf))
z=min(xs,xf)+((n-min(xs,xf))//k)*k
if z<=p:print("NO")
else:print("YES")
|
import math,sys;input=sys.stdin.readline;S=lambda:input().rstrip();I=lambda:int(S());M=lambda:map(int,S().split());L=lambda:list(M());mod1=1000000007;mod2=998244353
n,m=M();a=L();q=I()
t=[0]*(2*m)
# a is the array of initial values
def build(t,n,a):
for i in range(n):t[i+n]=a[i]
for i in range(n-1,0,-1):t[i]=max(t[i<<1],t[(i<<1)|1])
# change value at position p to v
def modify(t,n,p,v):
p+=n
t[p]=v
while p>1:
t[p>>1]=max(t[p],t[p^1])
p>>=1
# find the combined value of range [l,r)
def query(t,n,l,r):
resl=resr=0
l+=n;r+=n
while l<r:
if (l&1):{{completion}}
if (r&1):r-=1;resr=max(t[r],resr)
l>>=1;r>>=1
return max(resl,resr)
build(t,m,a)
for i in range(q):
xs,ys,xf,yf,k=M()
if abs(xs-xf)%k or abs(ys-yf)%k:print("NO");continue
p=query(t,m,min(ys,yf)-1,max(ys,yf))
z=min(xs,xf)+((n-min(xs,xf))//k)*k
if z<=p:print("NO")
else:print("YES")
|
resl=max(resl,t[l]);l+=1
|
[{"input": "11 10\n9 0 0 10 3 4 8 11 10 8\n6\n1 2 1 3 1\n1 2 1 3 2\n4 3 4 5 2\n5 3 11 5 3\n5 3 11 5 2\n11 9 9 10 1", "output": ["YES\nNO\nNO\nNO\nYES\nYES"]}]
|
block_completion_002999
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: While searching for the pizza, baby Hosssam came across two permutations $$$a$$$ and $$$b$$$ of length $$$n$$$.Recall that a permutation is an array consisting of $$$n$$$ distinct integers from $$$1$$$ to $$$n$$$ in arbitrary order. For example, $$$[2,3,1,5,4]$$$ is a permutation, but $$$[1,2,2]$$$ is not a permutation ($$$2$$$ appears twice in the array) and $$$[1,3,4]$$$ is also not a permutation ($$$n=3$$$ but there is $$$4$$$ in the array).Baby Hosssam forgot about the pizza and started playing around with the two permutations. While he was playing with them, some elements of the first permutation got mixed up with some elements of the second permutation, and to his surprise those elements also formed a permutation of size $$$n$$$.Specifically, he mixed up the permutations to form a new array $$$c$$$ in the following way. For each $$$i$$$ ($$$1\le i\le n$$$), he either made $$$c_i=a_i$$$ or $$$c_i=b_i$$$. The array $$$c$$$ is a permutation. You know permutations $$$a$$$, $$$b$$$, and values at some positions in $$$c$$$. Please count the number different permutations $$$c$$$ that are consistent with the described process and the given values. Since the answer can be large, print it modulo $$$10^9+7$$$.It is guaranteed that there exists at least one permutation $$$c$$$ that satisfies all the requirements.
Input Specification: The first line contains an integer $$$t$$$ ($$$1 \le t \le 10^5$$$) — the number of test cases. The first line of each test case contains a single integer $$$n$$$ ($$$1\le n\le 10^5$$$) — the length of the permutations. The next line contains $$$n$$$ distinct integers $$$a_1,a_2,\ldots,a_n$$$ ($$$1\le a_i\le n$$$) — the first permutation. The next line contains $$$n$$$ distinct integers $$$b_1,b_2,\ldots,b_n$$$ ($$$1\le b_i\le n$$$) — the second permutation. The next line contains $$$n$$$ distinct integers $$$d_1,d_2,\ldots,d_n$$$ ($$$d_i$$$ is either $$$0$$$, $$$a_i$$$, or $$$b_i$$$) — the description of the known values of $$$c$$$. If $$$d_i=0$$$, then there are no requirements on the value of $$$c_i$$$. Otherwise, it is required that $$$c_i=d_i$$$. It is guaranteed that there exists at least one permutation $$$c$$$ that satisfies all the requirements. It is guaranteed that the sum of $$$n$$$ over all test cases does not exceed $$$5 \cdot 10^5$$$.
Output Specification: For each test case, print the number of possible permutations $$$c$$$, modulo $$$10^9+7$$$.
Notes: NoteIn the first test case, there are $$$4$$$ distinct permutation that can be made using the process: $$$[2,3,1,4,5,6,7]$$$, $$$[2,3,1,7,6,5,4]$$$, $$$[2,3,1,4,6,5,7]$$$, $$$[2,3,1,7,5,6,4]$$$.In the second test case, there is only one distinct permutation that can be made using the process: $$$[1]$$$.In the third test case, there are $$$2$$$ distinct permutation that can be made using the process: $$$[6,5,2,1,4,3]$$$, $$$[6,5,3,1,4,2]$$$.In the fourth test case, there are $$$2$$$ distinct permutation that can be made using the process: $$$[1,2,8,7,4,3,6,5]$$$, $$$[1,6,4,7,2,3,8,5]$$$.In the fifth test case, there is only one distinct permutation that can be made using the process: $$$[1,9,2,3,4,10,8,6,7,5]$$$.
Code:
# read interger t from input.txt and then read t lines
import sys
DEBUG = False
def check(a, b, c):
a = [0] + a
b = [0] + b
c = [0] + c
m_ = [0] * len(a)
m = [0] * len(a)
for i in range(1, len(b)):
m_[b[i]] = i
for i in range(1, len(a)):
m[i] = m_[a[i]]
# print(">>>", a)
# print(">>>", b)
# print(">>>", m)
# find cicles in permutations
total_num = 1
used = [False] * len(m)
# print(a, b, c)
for i in range(1, len(m)):
if not used[i]:
j = i
c_zeros = True
while not used[j]:
if c[j] != 0:
# TODO: Your code here
used[j] = True
j = m[j]
used[i] = True
# print(i, m[i], a[i], b[i], c[i])
if c_zeros and m[i] != i:
# print(">>", i)
total_num = (total_num) * 2 % 1000000007
print(total_num)
def main(f):
t = int(f.readline())
for i in range(t):
n = int(f.readline())
a = list(map(int, f.readline().split()))
b = list(map(int, f.readline().split()))
c = list(map(int, f.readline().split()))
check(a, b, c)
if DEBUG:
f = open('input.txt', 'r')
else:
f = sys.stdin
main(f)
f.close()
|
# read interger t from input.txt and then read t lines
import sys
DEBUG = False
def check(a, b, c):
a = [0] + a
b = [0] + b
c = [0] + c
m_ = [0] * len(a)
m = [0] * len(a)
for i in range(1, len(b)):
m_[b[i]] = i
for i in range(1, len(a)):
m[i] = m_[a[i]]
# print(">>>", a)
# print(">>>", b)
# print(">>>", m)
# find cicles in permutations
total_num = 1
used = [False] * len(m)
# print(a, b, c)
for i in range(1, len(m)):
if not used[i]:
j = i
c_zeros = True
while not used[j]:
if c[j] != 0:
{{completion}}
used[j] = True
j = m[j]
used[i] = True
# print(i, m[i], a[i], b[i], c[i])
if c_zeros and m[i] != i:
# print(">>", i)
total_num = (total_num) * 2 % 1000000007
print(total_num)
def main(f):
t = int(f.readline())
for i in range(t):
n = int(f.readline())
a = list(map(int, f.readline().split()))
b = list(map(int, f.readline().split()))
c = list(map(int, f.readline().split()))
check(a, b, c)
if DEBUG:
f = open('input.txt', 'r')
else:
f = sys.stdin
main(f)
f.close()
|
c_zeros = False
|
[{"input": "9\n7\n1 2 3 4 5 6 7\n2 3 1 7 6 5 4\n2 0 1 0 0 0 0\n1\n1\n1\n0\n6\n1 5 2 4 6 3\n6 5 3 1 4 2\n6 0 0 0 0 0\n8\n1 6 4 7 2 3 8 5\n3 2 8 1 4 5 6 7\n1 0 0 7 0 3 0 5\n10\n1 8 6 2 4 7 9 3 10 5\n1 9 2 3 4 10 8 6 7 5\n1 9 2 3 4 10 8 6 7 5\n7\n1 2 3 4 5 6 7\n2 3 1 7 6 5 4\n0 0 0 0 0 0 0\n5\n1 2 3 4 5\n1 2 3 4 5\n0 0 0 0 0\n5\n1 2 3 4 5\n1 2 3 5 4\n0 0 0 0 0\n3\n1 2 3\n3 1 2\n0 0 0", "output": ["4\n1\n2\n2\n1\n8\n1\n2\n2"]}]
|
block_completion_006025
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: A triple of points $$$i$$$, $$$j$$$ and $$$k$$$ on a coordinate line is called beautiful if $$$i < j < k$$$ and $$$k - i \le d$$$.You are given a set of points on a coordinate line, initially empty. You have to process queries of three types: add a point; remove a point; calculate the number of beautiful triples consisting of points belonging to the set.
Input Specification: The first line contains two integers $$$q$$$ and $$$d$$$ ($$$1 \le q, d \le 2 \cdot 10^5$$$) — the number of queries and the parameter for defining if a triple is beautiful, respectively. The second line contains $$$q$$$ integers $$$a_1, a_2, \dots, a_q$$$ ($$$1 \le a_i \le 2 \cdot 10^5$$$) denoting the queries. The integer $$$a_i$$$ denotes the $$$i$$$-th query in the following way: if the point $$$a_i$$$ belongs to the set, remove it; otherwise, add it; after adding or removing the point, print the number of beautiful triples.
Output Specification: For each query, print one integer — the number of beautiful triples after processing the respective query.
Code:
import os
import sys
from io import BytesIO, IOBase
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")
class LazySegmentTree():
def __init__(self, n, op, e, mapping, composition, id):
self.n = n
self.op = op
self.e = e
self.mapping = mapping
self.composition = composition
self.id = id
self.log = (n - 1).bit_length()
self.size = 1 << self.log
self.data = [e] * (2 * self.size)
self.lazy = [id] * self.size
def update(self, k):
self.data[k] = self.op(self.data[2 * k], self.data[2 * k + 1])
def all_apply(self, k, f):
self.data[k] = self.mapping(f, self.data[k])
if k < self.size:
self.lazy[k] = self.composition(f, self.lazy[k])
def push(self, k):
self.all_apply(2 * k, self.lazy[k])
self.all_apply(2 * k + 1, self.lazy[k])
self.lazy[k] = self.id
def build(self, arr):
# assert len(arr) == self.n
for i, a in enumerate(arr):
self.data[self.size + i] = a
for i in range(self.size - 1, 0, -1):
self.update(i)
def set(self, p, x):
# assert 0 <= p < self.n
p += self.size
for i in range(self.log, 0, -1):
self.push(p >> i)
self.data[p] = x
for i in range(1, self.log + 1):
self.update(p >> i)
def get(self, p):
# assert 0 <= p < self.n
p += self.size
for i in range(self.log, 0, -1):
self.push(p >> i)
return self.data[p]
def prod(self, l, r):
# assert 0 <= l <= r <= self.n
if l == r: return self.e
l += self.size
r += self.size
for i in range(self.log, 0, -1):
if ((l >> i) << i) != l: # TODO: Your code here
if ((r >> i) << i) != r: self.push(r >> i)
sml = smr = self.e
while l < r:
if l & 1:
sml = self.op(sml, self.data[l])
l += 1
if r & 1:
r -= 1
smr = self.op(self.data[r], smr)
l >>= 1
r >>= 1
return self.op(sml, smr)
def all_prod(self):
return self.data[1]
def apply(self, p, f):
# assert 0 <= p < self.n
p += self.size
for i in range(self.log, 0, -1):
self.push(p >> i)
self.data[p] = self.mapping(f, self.data[p])
for i in range(1, self.log + 1):
self.update(p >> i)
def range_apply(self, l, r, f):
# assert 0 <= l <= r <= self.n
if l == r: return
l += self.size
r += self.size
for i in range(self.log, 0, -1):
if ((l >> i) << i) != l: self.push(l >> i)
if ((r >> i) << i) != r: self.push((r - 1) >> i)
l2 = l
r2 = r
while l < r:
if l & 1:
self.all_apply(l, f)
l += 1
if r & 1:
r -= 1
self.all_apply(r, f)
l >>= 1
r >>= 1
l = l2
r = r2
for i in range(1, self.log + 1):
if ((l >> i) << i) != l: self.update(l >> i)
if ((r >> i) << i) != r: self.update((r - 1) >> i)
n = 2*10**5+1
q, d = map(int, input().split())
arr = list(map(int, input().split()))
v = [0]*n
def op(x, y):
return [x[0]+y[0], x[1]+y[1], x[2]+y[2], x[3]]
def mapping(k, x):
return [x[0], k*x[0]+x[1], k*k*x[0]+2*k*x[1]+x[2], x[3]+k]
def composition(f, g):
return f+g
e = [0, 0, 0, 0]
id = 0
st = LazySegmentTree(n, op, e, mapping, composition, id)
st.build([[0, 0, 0, 0] for i in range(n)])
for x in arr:
v[x] ^= 1
m = st.get(x)[3]
if v[x]:
st.range_apply(x+1, min(x+d+1, n), 1)
st.set(x, [1, m, m*m, m])
else:
st.range_apply(x+1, min(x+d+1, n), -1)
st.set(x, [0, 0, 0, m])
a = st.all_prod()
print((a[2]-a[1])//2)
|
import os
import sys
from io import BytesIO, IOBase
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")
class LazySegmentTree():
def __init__(self, n, op, e, mapping, composition, id):
self.n = n
self.op = op
self.e = e
self.mapping = mapping
self.composition = composition
self.id = id
self.log = (n - 1).bit_length()
self.size = 1 << self.log
self.data = [e] * (2 * self.size)
self.lazy = [id] * self.size
def update(self, k):
self.data[k] = self.op(self.data[2 * k], self.data[2 * k + 1])
def all_apply(self, k, f):
self.data[k] = self.mapping(f, self.data[k])
if k < self.size:
self.lazy[k] = self.composition(f, self.lazy[k])
def push(self, k):
self.all_apply(2 * k, self.lazy[k])
self.all_apply(2 * k + 1, self.lazy[k])
self.lazy[k] = self.id
def build(self, arr):
# assert len(arr) == self.n
for i, a in enumerate(arr):
self.data[self.size + i] = a
for i in range(self.size - 1, 0, -1):
self.update(i)
def set(self, p, x):
# assert 0 <= p < self.n
p += self.size
for i in range(self.log, 0, -1):
self.push(p >> i)
self.data[p] = x
for i in range(1, self.log + 1):
self.update(p >> i)
def get(self, p):
# assert 0 <= p < self.n
p += self.size
for i in range(self.log, 0, -1):
self.push(p >> i)
return self.data[p]
def prod(self, l, r):
# assert 0 <= l <= r <= self.n
if l == r: return self.e
l += self.size
r += self.size
for i in range(self.log, 0, -1):
if ((l >> i) << i) != l: {{completion}}
if ((r >> i) << i) != r: self.push(r >> i)
sml = smr = self.e
while l < r:
if l & 1:
sml = self.op(sml, self.data[l])
l += 1
if r & 1:
r -= 1
smr = self.op(self.data[r], smr)
l >>= 1
r >>= 1
return self.op(sml, smr)
def all_prod(self):
return self.data[1]
def apply(self, p, f):
# assert 0 <= p < self.n
p += self.size
for i in range(self.log, 0, -1):
self.push(p >> i)
self.data[p] = self.mapping(f, self.data[p])
for i in range(1, self.log + 1):
self.update(p >> i)
def range_apply(self, l, r, f):
# assert 0 <= l <= r <= self.n
if l == r: return
l += self.size
r += self.size
for i in range(self.log, 0, -1):
if ((l >> i) << i) != l: self.push(l >> i)
if ((r >> i) << i) != r: self.push((r - 1) >> i)
l2 = l
r2 = r
while l < r:
if l & 1:
self.all_apply(l, f)
l += 1
if r & 1:
r -= 1
self.all_apply(r, f)
l >>= 1
r >>= 1
l = l2
r = r2
for i in range(1, self.log + 1):
if ((l >> i) << i) != l: self.update(l >> i)
if ((r >> i) << i) != r: self.update((r - 1) >> i)
n = 2*10**5+1
q, d = map(int, input().split())
arr = list(map(int, input().split()))
v = [0]*n
def op(x, y):
return [x[0]+y[0], x[1]+y[1], x[2]+y[2], x[3]]
def mapping(k, x):
return [x[0], k*x[0]+x[1], k*k*x[0]+2*k*x[1]+x[2], x[3]+k]
def composition(f, g):
return f+g
e = [0, 0, 0, 0]
id = 0
st = LazySegmentTree(n, op, e, mapping, composition, id)
st.build([[0, 0, 0, 0] for i in range(n)])
for x in arr:
v[x] ^= 1
m = st.get(x)[3]
if v[x]:
st.range_apply(x+1, min(x+d+1, n), 1)
st.set(x, [1, m, m*m, m])
else:
st.range_apply(x+1, min(x+d+1, n), -1)
st.set(x, [0, 0, 0, m])
a = st.all_prod()
print((a[2]-a[1])//2)
|
self.push(l >> i)
|
[{"input": "7 5\n8 5 3 2 1 5 6", "output": ["0\n0\n1\n2\n5\n1\n5"]}]
|
block_completion_005218
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: Polycarp has a string $$$s$$$ consisting of lowercase Latin letters.He encodes it using the following algorithm.He goes through the letters of the string $$$s$$$ from left to right and for each letter Polycarp considers its number in the alphabet: if the letter number is single-digit number (less than $$$10$$$), then just writes it out; if the letter number is a two-digit number (greater than or equal to $$$10$$$), then it writes it out and adds the number 0 after. For example, if the string $$$s$$$ is code, then Polycarp will encode this string as follows: 'c' — is the $$$3$$$-rd letter of the alphabet. Consequently, Polycarp adds 3 to the code (the code becomes equal to 3); 'o' — is the $$$15$$$-th letter of the alphabet. Consequently, Polycarp adds 15 to the code and also 0 (the code becomes 3150); 'd' — is the $$$4$$$-th letter of the alphabet. Consequently, Polycarp adds 4 to the code (the code becomes 31504); 'e' — is the $$$5$$$-th letter of the alphabet. Therefore, Polycarp adds 5 to the code (the code becomes 315045). Thus, code of string code is 315045.You are given a string $$$t$$$ resulting from encoding the string $$$s$$$. Your task is to decode it (get the original string $$$s$$$ by $$$t$$$).
Input Specification: The first line of the input contains an integer $$$q$$$ ($$$1 \le q \le 10^4$$$) — the number of test cases in the input. The descriptions of the test cases follow. The first line of description of each test case contains one integer $$$n$$$ ($$$1 \le n \le 50$$$) — the length of the given code. The second line of the description of each test case contains a string $$$t$$$ of length $$$n$$$ — the given code. It is guaranteed that there exists such a string of lowercase Latin letters, as a result of encoding which the string $$$t$$$ is obtained.
Output Specification: For each test case output the required string $$$s$$$ — the string that gives string $$$t$$$ as the result of encoding. It is guaranteed that such a string always exists. It can be shown that such a string is always unique.
Notes: NoteThe first test case is explained above.In the second test case, the answer is aj. Indeed, the number of the letter a is equal to $$$1$$$, so 1 will be appended to the code. The number of the letter j is $$$10$$$, so 100 will be appended to the code. The resulting code is 1100.There are no zeros in the third test case, which means that the numbers of all letters are less than $$$10$$$ and are encoded as one digit. The original string is abacaba.In the fourth test case, the string $$$s$$$ is equal to ll. The letter l has the number $$$12$$$ and is encoded as 120. So ll is indeed 120120.
Code:
from sys import stdin
from collections import deque
lst = list(map(int, stdin.read().split()))
_s = 0
def inp(n=1):
global _s
ret = lst[_s:_s + n]
_s += n
return ret
def inp1():
return inp()[0]
t = inp1()
for _ in range(t):
n = inp1()
s = str(inp1())[::-1]
alph = "0abcdefghijklmnopqrstuvwxyz"
d = deque()
i = 0
while i < n:
if # TODO: Your code here:
d.appendleft(int(s[i + 1:i + 3][::-1]))
i += 3
else:
d.appendleft(int(s[i]))
i += 1
ret = ""
for i in d:
ret += alph[i]
print(ret)
|
from sys import stdin
from collections import deque
lst = list(map(int, stdin.read().split()))
_s = 0
def inp(n=1):
global _s
ret = lst[_s:_s + n]
_s += n
return ret
def inp1():
return inp()[0]
t = inp1()
for _ in range(t):
n = inp1()
s = str(inp1())[::-1]
alph = "0abcdefghijklmnopqrstuvwxyz"
d = deque()
i = 0
while i < n:
if {{completion}}:
d.appendleft(int(s[i + 1:i + 3][::-1]))
i += 3
else:
d.appendleft(int(s[i]))
i += 1
ret = ""
for i in d:
ret += alph[i]
print(ret)
|
s[i] == "0"
|
[{"input": "9\n\n6\n\n315045\n\n4\n\n1100\n\n7\n\n1213121\n\n6\n\n120120\n\n18\n\n315045615018035190\n\n7\n\n1111110\n\n7\n\n1111100\n\n5\n\n11111\n\n4\n\n2606", "output": ["code\naj\nabacaba\nll\ncodeforces\naaaak\naaaaj\naaaaa\nzf"]}]
|
control_completion_008431
|
control_fixed
|
python
|
Complete the code in python to solve this programming problem:
Description: There are $$$n$$$ candies put from left to right on a table. The candies are numbered from left to right. The $$$i$$$-th candy has weight $$$w_i$$$. Alice and Bob eat candies. Alice can eat any number of candies from the left (she can't skip candies, she eats them in a row). Bob can eat any number of candies from the right (he can't skip candies, he eats them in a row). Of course, if Alice ate a candy, Bob can't eat it (and vice versa).They want to be fair. Their goal is to eat the same total weight of candies. What is the most number of candies they can eat in total?
Input Specification: The first line contains an integer $$$t$$$ ($$$1 \leq t \leq 10^4$$$) — the number of test cases. The first line of each test case contains an integer $$$n$$$ ($$$1 \leq n \leq 2\cdot10^5$$$) — the number of candies on the table. The second line of each test case contains $$$n$$$ integers $$$w_1, w_2, \dots, w_n$$$ ($$$1 \leq w_i \leq 10^4$$$) — the weights of candies from left to right. It is guaranteed that the sum of $$$n$$$ over all test cases does not exceed $$$2\cdot10^5$$$.
Output Specification: For each test case, print a single integer — the maximum number of candies Alice and Bob can eat in total while satisfying the condition.
Notes: NoteFor the first test case, Alice will eat one candy from the left and Bob will eat one candy from the right. There is no better way for them to eat the same total amount of weight. The answer is $$$2$$$ because they eat two candies in total.For the second test case, Alice will eat the first three candies from the left (with total weight $$$7$$$) and Bob will eat the first three candies from the right (with total weight $$$7$$$). They cannot eat more candies since all the candies have been eaten, so the answer is $$$6$$$ (because they eat six candies in total).For the third test case, there is no way Alice and Bob will eat the same non-zero weight so the answer is $$$0$$$.For the fourth test case, Alice will eat candies with weights $$$[7, 3, 20]$$$ and Bob will eat candies with weights $$$[10, 8, 11, 1]$$$, they each eat $$$30$$$ weight. There is no better partition so the answer is $$$7$$$.
Code:
for _ in range(int(input())):
n = int(input())
a = [*map(int, input().split())]
x = sum(a) // 2
s, d = 0, {}
for idx, i in enumerate(a):
s += i
if # TODO: Your code here: break
d[s] = idx + 1
s, r = 0, 0
for idx, i in enumerate(a[::-1]):
s += i
if s in d: r = idx + 1 + d[s]
print(r)
|
for _ in range(int(input())):
n = int(input())
a = [*map(int, input().split())]
x = sum(a) // 2
s, d = 0, {}
for idx, i in enumerate(a):
s += i
if {{completion}}: break
d[s] = idx + 1
s, r = 0, 0
for idx, i in enumerate(a[::-1]):
s += i
if s in d: r = idx + 1 + d[s]
print(r)
|
s > x
|
[{"input": "4\n3\n10 20 10\n6\n2 1 4 2 4 1\n5\n1 2 4 8 16\n9\n7 3 20 5 15 1 11 8 10", "output": ["2\n6\n0\n7"]}]
|
control_completion_000790
|
control_fixed
|
python
|
Complete the code in python to solve this programming problem:
Description: Tokitsukaze has a sequence $$$a$$$ of length $$$n$$$. For each operation, she selects two numbers $$$a_i$$$ and $$$a_j$$$ ($$$i \ne j$$$; $$$1 \leq i,j \leq n$$$). If $$$a_i = a_j$$$, change one of them to $$$0$$$. Otherwise change both of them to $$$\min(a_i, a_j)$$$. Tokitsukaze wants to know the minimum number of operations to change all numbers in the sequence to $$$0$$$. It can be proved that the answer always exists.
Input Specification: The first line contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 1000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 100$$$) — the length of the sequence $$$a$$$. The second line contains $$$n$$$ integers $$$a_1, a_2, \ldots, a_n$$$ ($$$0 \leq a_i \leq 100$$$) — the sequence $$$a$$$.
Output Specification: For each test case, print a single integer — the minimum number of operations to change all numbers in the sequence to $$$0$$$.
Notes: NoteIn the first test case, one of the possible ways to change all numbers in the sequence to $$$0$$$:In the $$$1$$$-st operation, $$$a_1 < a_2$$$, after the operation, $$$a_2 = a_1 = 1$$$. Now the sequence $$$a$$$ is $$$[1,1,3]$$$.In the $$$2$$$-nd operation, $$$a_1 = a_2 = 1$$$, after the operation, $$$a_1 = 0$$$. Now the sequence $$$a$$$ is $$$[0,1,3]$$$.In the $$$3$$$-rd operation, $$$a_1 < a_2$$$, after the operation, $$$a_2 = 0$$$. Now the sequence $$$a$$$ is $$$[0,0,3]$$$.In the $$$4$$$-th operation, $$$a_2 < a_3$$$, after the operation, $$$a_3 = 0$$$. Now the sequence $$$a$$$ is $$$[0,0,0]$$$.So the minimum number of operations is $$$4$$$.
Code:
for n in [*open(0)][2::2]:
*a,=map(int,n.split());b=len(a);c=a.count(0)
while a:
q=a.pop()
if # TODO: Your code here:
break
print(b+(a==[])*(c==0)-c)
|
for n in [*open(0)][2::2]:
*a,=map(int,n.split());b=len(a);c=a.count(0)
while a:
q=a.pop()
if {{completion}}:
break
print(b+(a==[])*(c==0)-c)
|
a.count(q)>0
|
[{"input": "3\n3\n1 2 3\n3\n1 2 2\n3\n1 2 0", "output": ["4\n3\n2"]}]
|
control_completion_008021
|
control_fixed
|
python
|
Complete the code in python to solve this programming problem:
Description: Suppose you had an array $$$A$$$ of $$$n$$$ elements, each of which is $$$0$$$ or $$$1$$$.Let us define a function $$$f(k,A)$$$ which returns another array $$$B$$$, the result of sorting the first $$$k$$$ elements of $$$A$$$ in non-decreasing order. For example, $$$f(4,[0,1,1,0,0,1,0]) = [0,0,1,1,0,1,0]$$$. Note that the first $$$4$$$ elements were sorted.Now consider the arrays $$$B_1, B_2,\ldots, B_n$$$ generated by $$$f(1,A), f(2,A),\ldots,f(n,A)$$$. Let $$$C$$$ be the array obtained by taking the element-wise sum of $$$B_1, B_2,\ldots, B_n$$$.For example, let $$$A=[0,1,0,1]$$$. Then we have $$$B_1=[0,1,0,1]$$$, $$$B_2=[0,1,0,1]$$$, $$$B_3=[0,0,1,1]$$$, $$$B_4=[0,0,1,1]$$$. Then $$$C=B_1+B_2+B_3+B_4=[0,1,0,1]+[0,1,0,1]+[0,0,1,1]+[0,0,1,1]=[0,2,2,4]$$$.You are given $$$C$$$. Determine a binary array $$$A$$$ that would give $$$C$$$ when processed as above. It is guaranteed that an array $$$A$$$ exists for given $$$C$$$ in the input.
Input Specification: The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 1000$$$) — the number of test cases. Each test case has two lines. The first line contains a single integer $$$n$$$ ($$$1 \leq n \leq 2 \cdot 10^5$$$). The second line contains $$$n$$$ integers $$$c_1, c_2, \ldots, c_n$$$ ($$$0 \leq c_i \leq n$$$). It is guaranteed that a valid array $$$A$$$ exists for the given $$$C$$$. The sum of $$$n$$$ over all test cases does not exceed $$$2 \cdot 10^5$$$.
Output Specification: For each test case, output a single line containing $$$n$$$ integers $$$a_1, a_2, \ldots, a_n$$$ ($$$a_i$$$ is $$$0$$$ or $$$1$$$). If there are multiple answers, you may output any of them.
Notes: NoteHere's the explanation for the first test case. Given that $$$A=[1,1,0,1]$$$, we can construct each $$$B_i$$$: $$$B_1=[\color{blue}{1},1,0,1]$$$; $$$B_2=[\color{blue}{1},\color{blue}{1},0,1]$$$; $$$B_3=[\color{blue}{0},\color{blue}{1},\color{blue}{1},1]$$$; $$$B_4=[\color{blue}{0},\color{blue}{1},\color{blue}{1},\color{blue}{1}]$$$ And then, we can sum up each column above to get $$$C=[1+1+0+0,1+1+1+1,0+0+1+1,1+1+1+1]=[2,4,2,4]$$$.
Code:
import sys
input = sys.stdin.readline
T = int(input())
for t in range(T):
N=int(input())
C=list(map(int,input().split()))
ans=[0]*N
k=sum(C)//N
i=N-1
while i>-1 and k>0:
if C[i]==N:
ans[i]=1
k-=1
else:
# TODO: Your code here
i-=1
print(*ans)
|
import sys
input = sys.stdin.readline
T = int(input())
for t in range(T):
N=int(input())
C=list(map(int,input().split()))
ans=[0]*N
k=sum(C)//N
i=N-1
while i>-1 and k>0:
if C[i]==N:
ans[i]=1
k-=1
else:
{{completion}}
i-=1
print(*ans)
|
C[i-k]+=N-i
|
[{"input": "5\n4\n2 4 2 4\n7\n0 3 4 2 3 2 7\n3\n0 0 0\n4\n0 0 0 4\n3\n1 2 3", "output": ["1 1 0 1 \n0 1 1 0 0 0 1 \n0 0 0 \n0 0 0 1 \n1 0 1"]}]
|
block_completion_008753
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given $$$n$$$ points on the plane, the coordinates of the $$$i$$$-th point are $$$(x_i, y_i)$$$. No two points have the same coordinates.The distance between points $$$i$$$ and $$$j$$$ is defined as $$$d(i,j) = |x_i - x_j| + |y_i - y_j|$$$.For each point, you have to choose a color, represented by an integer from $$$1$$$ to $$$n$$$. For every ordered triple of different points $$$(a,b,c)$$$, the following constraints should be met: if $$$a$$$, $$$b$$$ and $$$c$$$ have the same color, then $$$d(a,b) = d(a,c) = d(b,c)$$$; if $$$a$$$ and $$$b$$$ have the same color, and the color of $$$c$$$ is different from the color of $$$a$$$, then $$$d(a,b) < d(a,c)$$$ and $$$d(a,b) < d(b,c)$$$. Calculate the number of different ways to choose the colors that meet these constraints.
Input Specification: The first line contains one integer $$$n$$$ ($$$2 \le n \le 100$$$) — the number of points. Then $$$n$$$ lines follow. The $$$i$$$-th of them contains two integers $$$x_i$$$ and $$$y_i$$$ ($$$0 \le x_i, y_i \le 10^8$$$). No two points have the same coordinates (i. e. if $$$i \ne j$$$, then either $$$x_i \ne x_j$$$ or $$$y_i \ne y_j$$$).
Output Specification: Print one integer — the number of ways to choose the colors for the points. Since it can be large, print it modulo $$$998244353$$$.
Notes: NoteIn the first test, the following ways to choose the colors are suitable: $$$[1, 1, 1]$$$; $$$[2, 2, 2]$$$; $$$[3, 3, 3]$$$; $$$[1, 2, 3]$$$; $$$[1, 3, 2]$$$; $$$[2, 1, 3]$$$; $$$[2, 3, 1]$$$; $$$[3, 1, 2]$$$; $$$[3, 2, 1]$$$.
Code:
input = __import__('sys').stdin.readline
MOD = 998244353
fact = [1]
invfact = [1]
for i in range(1, 101):
fact.append(fact[-1] * i % MOD)
invfact.append(pow(fact[-1], MOD-2, MOD))
def C(n, k):
if k < 0 or k > n:
return 0
return fact[n] * invfact[k] % MOD * invfact[n-k] % MOD
def P(n, k):
if k < 0 or k > n:
return 0
return fact[n] * invfact[n-k] % MOD
n = int(input())
coords = []
for _ in range(n):
x, y = map(int, input().split())
coords.append((x, y))
min_dist = [10**9] * n
dist = [[-1] * n for _ in range(n)]
for u in range(n):
for v in range(n):
dist[u][v] = abs(coords[u][0] - coords[v][0]) + abs(coords[u][1] - coords[v][1])
if u != v:
min_dist[u] = min(min_dist[u], dist[u][v])
cnt = [0, 0, 0, 0, 0]
vis = [False]*n
for u in sorted(range(n), key=lambda x: min_dist[x]):
if vis[u]:
continue
vis[u] = True
seen = [False]*n
seen[u] = True
ptr = 0
found = [u]
while ptr < len(found):
v = found[ptr]
ptr += 1
for w in range(n):
if not seen[w] and dist[v][w] == min_dist[v]:
seen[w] = True
found.append(w)
ok = all(dist[found[i]][found[j]] == min_dist[u] for i in range(len(found)) for j in range(i+1, len(found)))
if len(found) == 1 or not ok:
cnt[1] += 1
else:
# print('found', found, ok)
cnt[len(found)] += 1
for u in found:
vis[u] = True
# print('cnt', cnt[1:])
ans = 0
for two in range(cnt[2] + 1):
for three in range(cnt[3] + 1):
for four in range(cnt[4] + 1):
ans += P(n, n - two - 2*three - 3*four) * C(cnt[2], two) % MOD \
* C(cnt[3], three) % MOD \
* C(cnt[4], four) % MOD
if ans >= MOD:
# TODO: Your code here
# print(f'add P({n},{n - two - 2*three - 3*four})*C({cnt[2]},{two})*C({cnt[3]},{three})*C({cnt[4]},{four}) {ans}')
print(ans)
|
input = __import__('sys').stdin.readline
MOD = 998244353
fact = [1]
invfact = [1]
for i in range(1, 101):
fact.append(fact[-1] * i % MOD)
invfact.append(pow(fact[-1], MOD-2, MOD))
def C(n, k):
if k < 0 or k > n:
return 0
return fact[n] * invfact[k] % MOD * invfact[n-k] % MOD
def P(n, k):
if k < 0 or k > n:
return 0
return fact[n] * invfact[n-k] % MOD
n = int(input())
coords = []
for _ in range(n):
x, y = map(int, input().split())
coords.append((x, y))
min_dist = [10**9] * n
dist = [[-1] * n for _ in range(n)]
for u in range(n):
for v in range(n):
dist[u][v] = abs(coords[u][0] - coords[v][0]) + abs(coords[u][1] - coords[v][1])
if u != v:
min_dist[u] = min(min_dist[u], dist[u][v])
cnt = [0, 0, 0, 0, 0]
vis = [False]*n
for u in sorted(range(n), key=lambda x: min_dist[x]):
if vis[u]:
continue
vis[u] = True
seen = [False]*n
seen[u] = True
ptr = 0
found = [u]
while ptr < len(found):
v = found[ptr]
ptr += 1
for w in range(n):
if not seen[w] and dist[v][w] == min_dist[v]:
seen[w] = True
found.append(w)
ok = all(dist[found[i]][found[j]] == min_dist[u] for i in range(len(found)) for j in range(i+1, len(found)))
if len(found) == 1 or not ok:
cnt[1] += 1
else:
# print('found', found, ok)
cnt[len(found)] += 1
for u in found:
vis[u] = True
# print('cnt', cnt[1:])
ans = 0
for two in range(cnt[2] + 1):
for three in range(cnt[3] + 1):
for four in range(cnt[4] + 1):
ans += P(n, n - two - 2*three - 3*four) * C(cnt[2], two) % MOD \
* C(cnt[3], three) % MOD \
* C(cnt[4], four) % MOD
if ans >= MOD:
{{completion}}
# print(f'add P({n},{n - two - 2*three - 3*four})*C({cnt[2]},{two})*C({cnt[3]},{three})*C({cnt[4]},{four}) {ans}')
print(ans)
|
ans -= MOD
|
[{"input": "3\n1 0\n3 0\n2 1", "output": ["9"]}, {"input": "5\n1 2\n2 4\n3 4\n4 4\n1 3", "output": ["240"]}, {"input": "4\n1 0\n3 0\n2 1\n2 0", "output": ["24"]}]
|
block_completion_000546
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given an array $$$a$$$ consisting of $$$n$$$ positive integers, and an array $$$b$$$, with length $$$n$$$. Initially $$$b_i=0$$$ for each $$$1 \leq i \leq n$$$.In one move you can choose an integer $$$i$$$ ($$$1 \leq i \leq n$$$), and add $$$a_i$$$ to $$$b_i$$$ or subtract $$$a_i$$$ from $$$b_i$$$. What is the minimum number of moves needed to make $$$b$$$ increasing (that is, every element is strictly greater than every element before it)?
Input Specification: The first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 5000$$$). The second line contains $$$n$$$ integers, $$$a_1$$$, $$$a_2$$$, ..., $$$a_n$$$ ($$$1 \leq a_i \leq 10^9$$$) — the elements of the array $$$a$$$.
Output Specification: Print a single integer, the minimum number of moves to make $$$b$$$ increasing.
Notes: NoteExample $$$1$$$: you can subtract $$$a_1$$$ from $$$b_1$$$, and add $$$a_3$$$, $$$a_4$$$, and $$$a_5$$$ to $$$b_3$$$, $$$b_4$$$, and $$$b_5$$$ respectively. The final array will be [$$$-1$$$, $$$0$$$, $$$3$$$, $$$4$$$, $$$5$$$] after $$$4$$$ moves.Example $$$2$$$: you can reach [$$$-3$$$, $$$-2$$$, $$$-1$$$, $$$0$$$, $$$1$$$, $$$2$$$, $$$3$$$] in $$$10$$$ moves.
Code:
for _ in range(1):
n = int(input())
a = list(map(int, input().split()))
Min = 1e18
for l in range(n):
m = a[l]
answer = 1
for i in range(l-1, -1, -1):
answer += (m + a[i]) // a[i]
m = a[i] * ((m + a[i]) // a[i])
if l + 1 < n:
m = 0
for i in range(l + 2, n):
# TODO: Your code here
Min = min(answer, Min)
print(Min)
|
for _ in range(1):
n = int(input())
a = list(map(int, input().split()))
Min = 1e18
for l in range(n):
m = a[l]
answer = 1
for i in range(l-1, -1, -1):
answer += (m + a[i]) // a[i]
m = a[i] * ((m + a[i]) // a[i])
if l + 1 < n:
m = 0
for i in range(l + 2, n):
{{completion}}
Min = min(answer, Min)
print(Min)
|
answer += (m + a[i]) // a[i]
m = a[i] * ((m + a[i]) // a[i])
|
[{"input": "5\n1 2 3 4 5", "output": ["4"]}, {"input": "7\n1 2 1 2 1 2 1", "output": ["10"]}, {"input": "8\n1 8 2 7 3 6 4 5", "output": ["16"]}]
|
block_completion_000979
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: Stanley has decided to buy a new desktop PC made by the company "Monoblock", and to solve captcha on their website, he needs to solve the following task.The awesomeness of an array is the minimum number of blocks of consecutive identical numbers in which the array could be split. For example, the awesomeness of an array $$$[1, 1, 1]$$$ is $$$1$$$; $$$[5, 7]$$$ is $$$2$$$, as it could be split into blocks $$$[5]$$$ and $$$[7]$$$; $$$[1, 7, 7, 7, 7, 7, 7, 7, 9, 9, 9, 9, 9, 9, 9, 9, 9]$$$ is 3, as it could be split into blocks $$$[1]$$$, $$$[7, 7, 7, 7, 7, 7, 7]$$$, and $$$[9, 9, 9, 9, 9, 9, 9, 9, 9]$$$. You are given an array $$$a$$$ of length $$$n$$$. There are $$$m$$$ queries of two integers $$$i$$$, $$$x$$$. A query $$$i$$$, $$$x$$$ means that from now on the $$$i$$$-th element of the array $$$a$$$ is equal to $$$x$$$.After each query print the sum of awesomeness values among all subsegments of array $$$a$$$. In other words, after each query you need to calculate $$$$$$\sum\limits_{l = 1}^n \sum\limits_{r = l}^n g(l, r),$$$$$$ where $$$g(l, r)$$$ is the awesomeness of the array $$$b = [a_l, a_{l + 1}, \ldots, a_r]$$$.
Input Specification: In the first line you are given with two integers $$$n$$$ and $$$m$$$ ($$$1 \leq n, m \leq 10^5$$$). The second line contains $$$n$$$ integers $$$a_1, a_2, \ldots, a_n$$$ ($$$1 \le a_i \le 10^9$$$) — the array $$$a$$$. In the next $$$m$$$ lines you are given the descriptions of queries. Each line contains two integers $$$i$$$ and $$$x$$$ ($$$1 \leq i \leq n$$$, $$$1 \leq x \leq 10^9$$$).
Output Specification: Print the answer to each query on a new line.
Notes: NoteAfter the first query $$$a$$$ is equal to $$$[1, 2, 2, 4, 5]$$$, and the answer is $$$29$$$ because we can split each of the subsegments the following way: $$$[1; 1]$$$: $$$[1]$$$, 1 block; $$$[1; 2]$$$: $$$[1] + [2]$$$, 2 blocks; $$$[1; 3]$$$: $$$[1] + [2, 2]$$$, 2 blocks; $$$[1; 4]$$$: $$$[1] + [2, 2] + [4]$$$, 3 blocks; $$$[1; 5]$$$: $$$[1] + [2, 2] + [4] + [5]$$$, 4 blocks; $$$[2; 2]$$$: $$$[2]$$$, 1 block; $$$[2; 3]$$$: $$$[2, 2]$$$, 1 block; $$$[2; 4]$$$: $$$[2, 2] + [4]$$$, 2 blocks; $$$[2; 5]$$$: $$$[2, 2] + [4] + [5]$$$, 3 blocks; $$$[3; 3]$$$: $$$[2]$$$, 1 block; $$$[3; 4]$$$: $$$[2] + [4]$$$, 2 blocks; $$$[3; 5]$$$: $$$[2] + [4] + [5]$$$, 3 blocks; $$$[4; 4]$$$: $$$[4]$$$, 1 block; $$$[4; 5]$$$: $$$[4] + [5]$$$, 2 blocks; $$$[5; 5]$$$: $$$[5]$$$, 1 block; which is $$$1 + 2 + 2 + 3 + 4 + 1 + 1 + 2 + 3 + 1 + 2 + 3 + 1 + 2 + 1 = 29$$$ in total.
Code:
from sys import stdin
input = stdin.readline
inp = lambda : list(map(int,input().split()))
def update(i , t):
global ans
if(i + 1 < n and a[i] == a[i + 1]):
ans += t * (i + 1)
else:
ans += t * (n - i) * (i + 1)
return ans
def answer():
global ans
ans = 0
for i in range(n):
update(i , 1)
for q in range(m):
i , x = inp()
i -= 1
if# TODO: Your code here:update(i - 1 , -1)
update(i , -1)
a[i] = x
if(i >= 0):update(i - 1 , 1)
update(i , 1)
print(ans)
for T in range(1):
n , m = inp()
a = inp()
answer()
|
from sys import stdin
input = stdin.readline
inp = lambda : list(map(int,input().split()))
def update(i , t):
global ans
if(i + 1 < n and a[i] == a[i + 1]):
ans += t * (i + 1)
else:
ans += t * (n - i) * (i + 1)
return ans
def answer():
global ans
ans = 0
for i in range(n):
update(i , 1)
for q in range(m):
i , x = inp()
i -= 1
if{{completion}}:update(i - 1 , -1)
update(i , -1)
a[i] = x
if(i >= 0):update(i - 1 , 1)
update(i , 1)
print(ans)
for T in range(1):
n , m = inp()
a = inp()
answer()
|
(i >= 0)
|
[{"input": "5 5\n1 2 3 4 5\n3 2\n4 2\n3 1\n2 1\n2 2", "output": ["29\n23\n35\n25\n35"]}]
|
control_completion_000077
|
control_fixed
|
python
|
Complete the code in python to solve this programming problem:
Description: There is a grid with $$$n$$$ rows and $$$m$$$ columns, and three types of cells: An empty cell, denoted with '.'. A stone, denoted with '*'. An obstacle, denoted with the lowercase Latin letter 'o'. All stones fall down until they meet the floor (the bottom row), an obstacle, or other stone which is already immovable. (In other words, all the stones just fall down as long as they can fall.)Simulate the process. What does the resulting grid look like?
Input Specification: The input consists of multiple test cases. The first line contains an integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains two integers $$$n$$$ and $$$m$$$ ($$$1 \leq n, m \leq 50$$$) — the number of rows and the number of columns in the grid, respectively. Then $$$n$$$ lines follow, each containing $$$m$$$ characters. Each of these characters is either '.', '*', or 'o' — an empty cell, a stone, or an obstacle, respectively.
Output Specification: For each test case, output a grid with $$$n$$$ rows and $$$m$$$ columns, showing the result of the process. You don't need to output a new line after each test, it is in the samples just for clarity.
Code:
t = int(input())
for i in range (t):
n, m = map(int,input().split())
arr = [[0]*m]*n
for j in range(n):
arr[j] = list(input())
# for h in range(m):
# print(arr[j][h])
for k in range(m):
for l in range(n-1, -1, -1):
if arr[l][k]=='.':
# print("yes")
for f in range(l-1,-1,-1):
if arr[f][k]=='o':
break
elif # TODO: Your code here:
# print("yes")
arr[f][k]='.'
arr[l][k]='*'
break
for g in range(n):
for h in range(m-1):
print(arr[g][h],end="")
print(arr[g][m-1],end="\n")
|
t = int(input())
for i in range (t):
n, m = map(int,input().split())
arr = [[0]*m]*n
for j in range(n):
arr[j] = list(input())
# for h in range(m):
# print(arr[j][h])
for k in range(m):
for l in range(n-1, -1, -1):
if arr[l][k]=='.':
# print("yes")
for f in range(l-1,-1,-1):
if arr[f][k]=='o':
break
elif {{completion}}:
# print("yes")
arr[f][k]='.'
arr[l][k]='*'
break
for g in range(n):
for h in range(m-1):
print(arr[g][h],end="")
print(arr[g][m-1],end="\n")
|
arr[f][k]=='*'
|
[{"input": "3\n6 10\n.*.*....*.\n.*.......*\n...o....o.\n.*.*....*.\n..........\n.o......o*\n2 9\n...***ooo\n.*o.*o.*o\n5 5\n*****\n*....\n*****\n....*\n*****", "output": ["..........\n...*....*.\n.*.o....o.\n.*........\n.*......**\n.o.*....o*\n\n....**ooo\n.*o**o.*o\n\n.....\n*...*\n*****\n*****\n*****"]}]
|
control_completion_000838
|
control_fixed
|
python
|
Complete the code in python to solve this programming problem:
Description: Monocarp plays "Rage of Empires II: Definitive Edition" — a strategic computer game. Right now he's planning to attack his opponent in the game, but Monocarp's forces cannot enter the opponent's territory since the opponent has built a wall.The wall consists of $$$n$$$ sections, aligned in a row. The $$$i$$$-th section initially has durability $$$a_i$$$. If durability of some section becomes $$$0$$$ or less, this section is considered broken.To attack the opponent, Monocarp needs to break at least two sections of the wall (any two sections: possibly adjacent, possibly not). To do this, he plans to use an onager — a special siege weapon. The onager can be used to shoot any section of the wall; the shot deals $$$2$$$ damage to the target section and $$$1$$$ damage to adjacent sections. In other words, if the onager shoots at the section $$$x$$$, then the durability of the section $$$x$$$ decreases by $$$2$$$, and the durability of the sections $$$x - 1$$$ and $$$x + 1$$$ (if they exist) decreases by $$$1$$$ each. Monocarp can shoot at any sections any number of times, he can even shoot at broken sections.Monocarp wants to calculate the minimum number of onager shots needed to break at least two sections. Help him!
Input Specification: The first line contains one integer $$$n$$$ ($$$2 \le n \le 2 \cdot 10^5$$$) — the number of sections. The second line contains the sequence of integers $$$a_1, a_2, \dots, a_n$$$ ($$$1 \le a_i \le 10^6$$$), where $$$a_i$$$ is the initial durability of the $$$i$$$-th section.
Output Specification: Print one integer — the minimum number of onager shots needed to break at least two sections of the wall.
Notes: NoteIn the first example, it is possible to break the $$$2$$$-nd and the $$$4$$$-th section in $$$10$$$ shots, for example, by shooting the third section $$$10$$$ times. After that, the durabilities become $$$[20, 0, 10, 0, 20]$$$. Another way of doing it is firing $$$5$$$ shots at the $$$2$$$-nd section, and another $$$5$$$ shots at the $$$4$$$-th section. After that, the durabilities become $$$[15, 0, 20, 0, 15]$$$.In the second example, it is enough to shoot the $$$2$$$-nd section once. Then the $$$1$$$-st and the $$$3$$$-rd section will be broken.In the third example, it is enough to shoot the $$$2$$$-nd section twice (then the durabilities become $$$[5, 2, 4, 8, 5, 8]$$$), and then shoot the $$$3$$$-rd section twice (then the durabilities become $$$[5, 0, 0, 6, 5, 8]$$$). So, four shots are enough to break the $$$2$$$-nd and the $$$3$$$-rd section.
Code:
N=int(input())
A=[int(x) for x in input().split()]
B=sorted(A)
ans=-(-B[0]//2)-(-B[1]//2)
for i in range(N-2):
# TODO: Your code here
for i in range(N-1):
score=max(-(-(A[i]+A[i+1])//3),-(-A[i]//2),-(-A[i+1]//2))
ans=min(score,ans)
print(ans)
|
N=int(input())
A=[int(x) for x in input().split()]
B=sorted(A)
ans=-(-B[0]//2)-(-B[1]//2)
for i in range(N-2):
{{completion}}
for i in range(N-1):
score=max(-(-(A[i]+A[i+1])//3),-(-A[i]//2),-(-A[i+1]//2))
ans=min(score,ans)
print(ans)
|
ans=min(ans,-(-(A[i]+A[i+2])//2))
|
[{"input": "5\n20 10 30 10 20", "output": ["10"]}, {"input": "3\n1 8 1", "output": ["1"]}, {"input": "6\n7 6 6 8 5 8", "output": ["4"]}, {"input": "6\n14 3 8 10 15 4", "output": ["4"]}, {"input": "4\n1 100 100 1", "output": ["2"]}, {"input": "3\n40 10 10", "output": ["7"]}]
|
block_completion_007904
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: The store sells $$$n$$$ items, the price of the $$$i$$$-th item is $$$p_i$$$. The store's management is going to hold a promotion: if a customer purchases at least $$$x$$$ items, $$$y$$$ cheapest of them are free.The management has not yet decided on the exact values of $$$x$$$ and $$$y$$$. Therefore, they ask you to process $$$q$$$ queries: for the given values of $$$x$$$ and $$$y$$$, determine the maximum total value of items received for free, if a customer makes one purchase.Note that all queries are independent; they don't affect the store's stock.
Input Specification: The first line contains two integers $$$n$$$ and $$$q$$$ ($$$1 \le n, q \le 2 \cdot 10^5$$$) — the number of items in the store and the number of queries, respectively. The second line contains $$$n$$$ integers $$$p_1, p_2, \dots, p_n$$$ ($$$1 \le p_i \le 10^6$$$), where $$$p_i$$$ — the price of the $$$i$$$-th item. The following $$$q$$$ lines contain two integers $$$x_i$$$ and $$$y_i$$$ each ($$$1 \le y_i \le x_i \le n$$$) — the values of the parameters $$$x$$$ and $$$y$$$ in the $$$i$$$-th query.
Output Specification: For each query, print a single integer — the maximum total value of items received for free for one purchase.
Notes: NoteIn the first query, a customer can buy three items worth $$$5, 3, 5$$$, the two cheapest of them are $$$3 + 5 = 8$$$.In the second query, a customer can buy two items worth $$$5$$$ and $$$5$$$, the cheapest of them is $$$5$$$.In the third query, a customer has to buy all the items to receive the three cheapest of them for free; their total price is $$$1 + 2 + 3 = 6$$$.
Code:
arr=[int(i) for i in input().split()]
ans=[]
prices=[int(i) for i in input().split()]
prices.sort(reverse=True)
for i in range(1,arr[0]):
prices[i]=prices[i]+prices[i-1]
for i in range(arr[1]):
xy=[int(i) for i in input().split()]
if# TODO: Your code here:
ans.append(prices[xy[0]-1])
else:
ans.append(prices[xy[0]-1]-prices[xy[0]-xy[1]-1])
for ele in ans:
print(ele)
|
arr=[int(i) for i in input().split()]
ans=[]
prices=[int(i) for i in input().split()]
prices.sort(reverse=True)
for i in range(1,arr[0]):
prices[i]=prices[i]+prices[i-1]
for i in range(arr[1]):
xy=[int(i) for i in input().split()]
if{{completion}}:
ans.append(prices[xy[0]-1])
else:
ans.append(prices[xy[0]-1]-prices[xy[0]-xy[1]-1])
for ele in ans:
print(ele)
|
(xy[0]==xy[1])
|
[{"input": "5 3\n5 3 1 5 2\n3 2\n1 1\n5 3", "output": ["8\n5\n6"]}]
|
control_completion_000508
|
control_fixed
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given $$$n$$$ segments on the coordinate axis. The $$$i$$$-th segment is $$$[l_i, r_i]$$$. Let's denote the set of all integer points belonging to the $$$i$$$-th segment as $$$S_i$$$.Let $$$A \cup B$$$ be the union of two sets $$$A$$$ and $$$B$$$, $$$A \cap B$$$ be the intersection of two sets $$$A$$$ and $$$B$$$, and $$$A \oplus B$$$ be the symmetric difference of $$$A$$$ and $$$B$$$ (a set which contains all elements of $$$A$$$ and all elements of $$$B$$$, except for the ones that belong to both sets).Let $$$[\mathbin{op}_1, \mathbin{op}_2, \dots, \mathbin{op}_{n-1}]$$$ be an array where each element is either $$$\cup$$$, $$$\oplus$$$, or $$$\cap$$$. Over all $$$3^{n-1}$$$ ways to choose this array, calculate the sum of the following values:$$$$$$|(((S_1\ \mathbin{op}_1\ S_2)\ \mathbin{op}_2\ S_3)\ \mathbin{op}_3\ S_4)\ \dots\ \mathbin{op}_{n-1}\ S_n|$$$$$$In this expression, $$$|S|$$$ denotes the size of the set $$$S$$$.
Input Specification: The first line contains one integer $$$n$$$ ($$$2 \le n \le 3 \cdot 10^5$$$). Then, $$$n$$$ lines follow. The $$$i$$$-th of them contains two integers $$$l_i$$$ and $$$r_i$$$ ($$$0 \le l_i \le r_i \le 3 \cdot 10^5$$$).
Output Specification: Print one integer — the sum of $$$|(((S_1\ \mathbin{op}_1\ S_2)\ \mathbin{op}_2\ S_3)\ \mathbin{op}_3\ S_4)\ \dots\ \mathbin{op}_{n-1}\ S_n|$$$ over all possible ways to choose $$$[\mathbin{op}_1, \mathbin{op}_2, \dots, \mathbin{op}_{n-1}]$$$. Since the answer can be huge, print it modulo $$$998244353$$$.
Code:
import sys
import heapq
from collections import Counter
# sys.setrecursionlimit(10000)
def input_general():
return sys.stdin.readline().rstrip('\r\n')
def input_num():
return int(sys.stdin.readline().rstrip("\r\n"))
def input_multi(x=int):
return map(x, sys.stdin.readline().rstrip("\r\n").split())
def input_list(x=int):
return list(input_multi(x))
def main():
def mod_pow(p, a, e):
base = a
answer = 1
while e:
if e & 1:
# TODO: Your code here
base = (base * base) % p
e >>= 1
return answer
n = input_num()
hp = []
pos = [[] for _ in range(300001)]
for i in range(n):
l, r = input_multi()
pos[l].append((i, r + 1))
P = 998244353
two_inv = (P + 1) // 2
loc = [-1] * 300001
for i in range(300001):
for (idx, r) in pos[i]:
heapq.heappush(hp, (-idx, r))
while hp and hp[0][1] <= i:
heapq.heappop(hp)
if hp:
loc[i] = -hp[0][0]
ctr = Counter(loc)
max_loc = max(ctr.keys())
curr = mod_pow(P, 2, n - 1)
answer = (curr * (ctr[0] + ctr[1])) % P
for i in range(2, max_loc + 1):
curr = (curr * two_inv * 3) % P
answer = (answer + curr * ctr[i]) % P
print(answer)
if __name__ == "__main__":
# cases = input_num()
#
# for _ in range(cases):
main()
|
import sys
import heapq
from collections import Counter
# sys.setrecursionlimit(10000)
def input_general():
return sys.stdin.readline().rstrip('\r\n')
def input_num():
return int(sys.stdin.readline().rstrip("\r\n"))
def input_multi(x=int):
return map(x, sys.stdin.readline().rstrip("\r\n").split())
def input_list(x=int):
return list(input_multi(x))
def main():
def mod_pow(p, a, e):
base = a
answer = 1
while e:
if e & 1:
{{completion}}
base = (base * base) % p
e >>= 1
return answer
n = input_num()
hp = []
pos = [[] for _ in range(300001)]
for i in range(n):
l, r = input_multi()
pos[l].append((i, r + 1))
P = 998244353
two_inv = (P + 1) // 2
loc = [-1] * 300001
for i in range(300001):
for (idx, r) in pos[i]:
heapq.heappush(hp, (-idx, r))
while hp and hp[0][1] <= i:
heapq.heappop(hp)
if hp:
loc[i] = -hp[0][0]
ctr = Counter(loc)
max_loc = max(ctr.keys())
curr = mod_pow(P, 2, n - 1)
answer = (curr * (ctr[0] + ctr[1])) % P
for i in range(2, max_loc + 1):
curr = (curr * two_inv * 3) % P
answer = (answer + curr * ctr[i]) % P
print(answer)
if __name__ == "__main__":
# cases = input_num()
#
# for _ in range(cases):
main()
|
answer = (answer * base) % p
|
[{"input": "4\n3 5\n4 8\n2 2\n1 9", "output": ["162"]}, {"input": "4\n1 9\n3 5\n4 8\n2 2", "output": ["102"]}]
|
block_completion_002199
|
block
|
End of preview. Expand
in Data Studio
README.md exists but content is empty.
- Downloads last month
- 90