prompt
stringlengths 87
14k
| solution
stringlengths 18
289k
| input_output
stringlengths 1
5.71k
| difficulty
stringclasses 3
values |
|---|---|---|---|
def ZblBQ():
"""Polycarp has $n$ different binary words. A word called binary if it contains only characters '0' and '1'. For example, these words are binary: "0001", "11", "0" and "0011100".
Polycarp wants to offer his set of $n$ binary words to play a game "words". In this game, players name words and each next word (starting from the second) must start with the last character of the previous word. The first word can be any. For example, these sequence of words can be named during the game: "0101", "1", "10", "00", "00001".
Word reversal is the operation of reversing the order of the characters. For example, the word "0111" after the reversal becomes "1110", the word "11010" after the reversal becomes "01011".
Probably, Polycarp has such a set of words that there is no way to put them in the order correspondent to the game rules. In this situation, he wants to reverse some words from his set so that: the final set of $n$ words still contains different words (i.e. all words are unique); there is a way to put all words of the final set of words in the order so that the final sequence of $n$ words is consistent with the game rules.
Polycarp wants to reverse minimal number of words. Please, help him.
-----Input-----
The first line of the input contains one integer $t$ ($1 \le t \le 10^4$) β the number of test cases in the input. Then $t$ test cases follow.
The first line of a test case contains one integer $n$ ($1 \le n \le 2\cdot10^5$) β the number of words in the Polycarp's set. Next $n$ lines contain these words. All of $n$ words aren't empty and contains only characters '0' and '1'. The sum of word lengths doesn't exceed $4\cdot10^6$. All words are different.
Guaranteed, that the sum of $n$ for all test cases in the input doesn't exceed $2\cdot10^5$. Also, guaranteed that the sum of word lengths for all test cases in the input doesn't exceed $4\cdot10^6$.
-----Output-----
Print answer for all of $t$ test cases in the order they appear.
If there is no answer for the test case, print -1. Otherwise, the first line of the output should contain $k$ ($0 \le k \le n$) β the minimal number of words in the set which should be reversed. The second line of the output should contain $k$ distinct integers β the indexes of the words in the set which should be reversed. Words are numerated from $1$ to $n$ in the order they appear. If $k=0$ you can skip this line (or you can print an empty line). If there are many answers you can print any of them.
-----Example-----
Input
4
4
0001
1000
0011
0111
3
010
101
0
2
00000
00001
4
01
001
0001
00001
Output
1
3
-1
0
2
1 2
"""
|
def ZblBQ():
for _ in range(int(input())):
n = int(input())
mass = []
zo = 0
oz = 0
zz = 0
oo = 0
ozs = []
zos = []
ozss = set()
zoss = set()
for j in range(n):
k = input()
mass.append(k)
if k[0] == '0' and k[-1] == '1':
zoss.add(k)
zos.append(j + 1)
zo += 1
elif k[0] == '1' and k[-1] == '0':
ozss.add(k)
ozs.append(j + 1)
oz += 1
elif k[0] == '0' and k[-1] == '0':
zz += 1
else:
oo += 1
if zz and oo and not oz and not zo:
print(-1)
continue
else:
if zo > oz:
print((zo - oz) // 2)
ans = []
need = (zo - oz) // 2
i = 0
while need:
zzz = mass[zos[i] - 1][len(mass[zos[i] - 1]) - 1:: -1]
if zzz not in ozss:
ans.append(zos[i])
need -= 1
i += 1
print(*ans)
else:
print((oz - zo) // 2)
ans = []
need = (oz - zo) // 2
i = 0
while need:
zzz = mass[ozs[i] - 1][len(mass[ozs[i] - 1]) - 1:: -1]
if zzz not in zoss:
ans.append(ozs[i])
need -= 1
i += 1
print(*ans)
| 4
4
0001
1000
0011
0111
3
010
101
0
2
00000
00001
4
01
001
0001
00001
| interview |
def zyBwn():
"""Mikhail walks on a Cartesian plane. He starts at the point $(0, 0)$, and in one move he can go to any of eight adjacent points. For example, if Mikhail is currently at the point $(0, 0)$, he can go to any of the following points in one move: $(1, 0)$; $(1, 1)$; $(0, 1)$; $(-1, 1)$; $(-1, 0)$; $(-1, -1)$; $(0, -1)$; $(1, -1)$.
If Mikhail goes from the point $(x1, y1)$ to the point $(x2, y2)$ in one move, and $x1 \ne x2$ and $y1 \ne y2$, then such a move is called a diagonal move.
Mikhail has $q$ queries. For the $i$-th query Mikhail's target is to go to the point $(n_i, m_i)$ from the point $(0, 0)$ in exactly $k_i$ moves. Among all possible movements he want to choose one with the maximum number of diagonal moves. Your task is to find the maximum number of diagonal moves or find that it is impossible to go from the point $(0, 0)$ to the point $(n_i, m_i)$ in $k_i$ moves.
Note that Mikhail can visit any point any number of times (even the destination point!).
-----Input-----
The first line of the input contains one integer $q$ ($1 \le q \le 10^4$) β the number of queries.
Then $q$ lines follow. The $i$-th of these $q$ lines contains three integers $n_i$, $m_i$ and $k_i$ ($1 \le n_i, m_i, k_i \le 10^{18}$) β $x$-coordinate of the destination point of the query, $y$-coordinate of the destination point of the query and the number of moves in the query, correspondingly.
-----Output-----
Print $q$ integers. The $i$-th integer should be equal to -1 if Mikhail cannot go from the point $(0, 0)$ to the point $(n_i, m_i)$ in exactly $k_i$ moves described above. Otherwise the $i$-th integer should be equal to the the maximum number of diagonal moves among all possible movements.
-----Example-----
Input
3
2 2 3
4 3 7
10 1 9
Output
1
6
-1
-----Note-----
One of the possible answers to the first test case: $(0, 0) \to (1, 0) \to (1, 1) \to (2, 2)$.
One of the possible answers to the second test case: $(0, 0) \to (0, 1) \to (1, 2) \to (0, 3) \to (1, 4) \to (2, 3) \to (3, 2) \to (4, 3)$.
In the third test case Mikhail cannot reach the point $(10, 1)$ in 9 moves.
"""
|
def zyBwn():
q=int(input())
for e in range(q):
x,y,k=list(map(int,input().split()))
x,y=abs(x),abs(y)
x,y=max(x,y),min(x,y)
if(x%2!=k%2):
k-=1
y-=1
if(x>k):
print(-1)
continue
if((x-y)%2):
k-=1
x-=1
print(k)
| 3
2 2 3
4 3 7
10 1 9
| interview |
def afqQi():
"""You have $n$ barrels lined up in a row, numbered from left to right from one. Initially, the $i$-th barrel contains $a_i$ liters of water.
You can pour water from one barrel to another. In one act of pouring, you can choose two different barrels $x$ and $y$ (the $x$-th barrel shouldn't be empty) and pour any possible amount of water from barrel $x$ to barrel $y$ (possibly, all water). You may assume that barrels have infinite capacity, so you can pour any amount of water in each of them.
Calculate the maximum possible difference between the maximum and the minimum amount of water in the barrels, if you can pour water at most $k$ times.
Some examples: if you have four barrels, each containing $5$ liters of water, and $k = 1$, you may pour $5$ liters from the second barrel into the fourth, so the amounts of water in the barrels are $[5, 0, 5, 10]$, and the difference between the maximum and the minimum is $10$; if all barrels are empty, you can't make any operation, so the difference between the maximum and the minimum amount is still $0$.
-----Input-----
The first line contains one integer $t$ ($1 \le t \le 1000$)Β β the number of test cases.
The first line of each test case contains two integers $n$ and $k$ ($1 \le k < n \le 2 \cdot 10^5$)Β β the number of barrels and the number of pourings you can make.
The second line contains $n$ integers $a_1, a_2, \dots, a_n$ ($0 \le a_i \le 10^{9}$), where $a_i$ is the initial amount of water the $i$-th barrel has.
It's guaranteed that the total sum of $n$ over test cases doesn't exceed $2 \cdot 10^5$.
-----Output-----
For each test case, print the maximum possible difference between the maximum and the minimum amount of water in the barrels, if you can pour water at most $k$ times.
-----Example-----
Input
2
4 1
5 5 5 5
3 2
0 0 0
Output
10
0
"""
|
def afqQi():
def solve():
n, k = map(int,input().split())
lst = list(map(int,input().split()))
lst.sort()
ans = 0
for i in range(n - k - 1, n):
ans += lst[i]
print(ans)
for i in range(int(input())):
solve() | 2
4 1
5 5 5 5
3 2
0 0 0
| interview |
def kSlmo():
"""You are given a permutation $p=[p_1, p_2, \ldots, p_n]$ of integers from $1$ to $n$. Let's call the number $m$ ($1 \le m \le n$) beautiful, if there exists two indices $l, r$ ($1 \le l \le r \le n$), such that the numbers $[p_l, p_{l+1}, \ldots, p_r]$ is a permutation of numbers $1, 2, \ldots, m$.
For example, let $p = [4, 5, 1, 3, 2, 6]$. In this case, the numbers $1, 3, 5, 6$ are beautiful and $2, 4$ are not. It is because: if $l = 3$ and $r = 3$ we will have a permutation $[1]$ for $m = 1$; if $l = 3$ and $r = 5$ we will have a permutation $[1, 3, 2]$ for $m = 3$; if $l = 1$ and $r = 5$ we will have a permutation $[4, 5, 1, 3, 2]$ for $m = 5$; if $l = 1$ and $r = 6$ we will have a permutation $[4, 5, 1, 3, 2, 6]$ for $m = 6$; it is impossible to take some $l$ and $r$, such that $[p_l, p_{l+1}, \ldots, p_r]$ is a permutation of numbers $1, 2, \ldots, m$ for $m = 2$ and for $m = 4$.
You are given a permutation $p=[p_1, p_2, \ldots, p_n]$. For all $m$ ($1 \le m \le n$) determine if it is a beautiful number or not.
-----Input-----
The first line contains the only integer $t$ ($1 \le t \le 1000$) Β β the number of test cases in the input. The next lines contain the description of test cases.
The first line of a test case contains a number $n$ ($1 \le n \le 2 \cdot 10^5$)Β β the length of the given permutation $p$. The next line contains $n$ integers $p_1, p_2, \ldots, p_n$ ($1 \le p_i \le n$, all $p_i$ are different)Β β the given permutation $p$.
It is guaranteed, that the sum of $n$ from all test cases in the input doesn't exceed $2 \cdot 10^5$.
-----Output-----
Print $t$ linesΒ β the answers to test cases in the order they are given in the input.
The answer to a test case is the string of length $n$, there the $i$-th character is equal to $1$ if $i$ is a beautiful number and is equal to $0$ if $i$ is not a beautiful number.
-----Example-----
Input
3
6
4 5 1 3 2 6
5
5 3 1 2 4
4
1 4 3 2
Output
101011
11111
1001
-----Note-----
The first test case is described in the problem statement.
In the second test case all numbers from $1$ to $5$ are beautiful: if $l = 3$ and $r = 3$ we will have a permutation $[1]$ for $m = 1$; if $l = 3$ and $r = 4$ we will have a permutation $[1, 2]$ for $m = 2$; if $l = 2$ and $r = 4$ we will have a permutation $[3, 1, 2]$ for $m = 3$; if $l = 2$ and $r = 5$ we will have a permutation $[3, 1, 2, 4]$ for $m = 4$; if $l = 1$ and $r = 5$ we will have a permutation $[5, 3, 1, 2, 4]$ for $m = 5$.
"""
|
def kSlmo():
for _ in range(int(input())):
input()
nums = [int(x) for x in input().split()]
new_ar = list(zip(nums,[i for i in range(len(nums))]))
new_ar.sort()
maxx = new_ar[0][1]
minn = new_ar[0][1]
s="1"
for j in range(1,len(new_ar)):
if(new_ar[j][1]>maxx):
maxx = new_ar[j][1]
if(new_ar[j][1]<minn):
minn = new_ar[j][1]
if(maxx-minn<j+1):
s+="1"
else:
s+="0"
print(s) | 3
6
4 5 1 3 2 6
5
5 3 1 2 4
4
1 4 3 2
| interview |
def OTbYC():
"""The sequence of $m$ integers is called the permutation if it contains all integers from $1$ to $m$ exactly once. The number $m$ is called the length of the permutation.
Dreamoon has two permutations $p_1$ and $p_2$ of non-zero lengths $l_1$ and $l_2$.
Now Dreamoon concatenates these two permutations into another sequence $a$ of length $l_1 + l_2$. First $l_1$ elements of $a$ is the permutation $p_1$ and next $l_2$ elements of $a$ is the permutation $p_2$.
You are given the sequence $a$, and you need to find two permutations $p_1$ and $p_2$. If there are several possible ways to restore them, you should find all of them. (Note that it is also possible that there will be no ways.)
-----Input-----
The first line contains an integer $t$ ($1 \le t \le 10\,000$) denoting the number of test cases in the input.
Each test case contains two lines. The first line contains one integer $n$ ($2 \leq n \leq 200\,000$): the length of $a$. The second line contains $n$ integers $a_1, a_2, \ldots, a_n$ ($1 \leq a_i \leq n-1$).
The total sum of $n$ is less than $200\,000$.
-----Output-----
For each test case, the first line of output should contain one integer $k$: the number of ways to divide $a$ into permutations $p_1$ and $p_2$.
Each of the next $k$ lines should contain two integers $l_1$ and $l_2$ ($1 \leq l_1, l_2 \leq n, l_1 + l_2 = n$), denoting, that it is possible to divide $a$ into two permutations of length $l_1$ and $l_2$ ($p_1$ is the first $l_1$ elements of $a$, and $p_2$ is the last $l_2$ elements of $a$). You can print solutions in any order.
-----Example-----
Input
6
5
1 4 3 2 1
6
2 4 1 3 2 1
4
2 1 1 3
4
1 3 3 1
12
2 1 3 4 5 6 7 8 9 1 10 2
3
1 1 1
Output
2
1 4
4 1
1
4 2
0
0
1
2 10
0
-----Note-----
In the first example, two possible ways to divide $a$ into permutations are $\{1\} + \{4, 3, 2, 1\}$ and $\{1,4,3,2\} + \{1\}$.
In the second example, the only way to divide $a$ into permutations is $\{2,4,1,3\} + \{2,1\}$.
In the third example, there are no possible ways.
"""
|
def OTbYC():
def possible(a):
ans = set()
s = set()
lmax = 0
for i in range(len(a)):
lmax = max(lmax, a[i])
s.add(a[i])
if lmax == i + 1 and len(s) == i + 1:
ans.add(i + 1)
return ans
t = int(input())
for case_num in range(t):
n = int(input())
a = list(map(int, input().split(' ')))
left = possible(a)
a.reverse()
right = possible(a)
ans = []
for l in left:
if n - l in right:
ans.append(l)
print(len(ans))
for l in ans:
print(l, n - l)
| 6
5
1 4 3 2 1
6
2 4 1 3 2 1
4
2 1 1 3
4
1 3 3 1
12
2 1 3 4 5 6 7 8 9 1 10 2
3
1 1 1
| interview |
def nPZoD():
"""Arthur owns a ski resort on a mountain. There are $n$ landing spots on the mountain numbered from $1$ to $n$ from the top to the foot of the mountain. The spots are connected with one-directional ski tracks. All tracks go towards the foot of the mountain, so there are no directed cycles formed by the tracks. There are at most two tracks leaving each spot, but many tracks may enter the same spot.
A skier can start skiing from one spot and stop in another spot if there is a sequence of tracks that lead from the starting spot and end in the ending spot. Unfortunately, recently there were many accidents, because the structure of the resort allows a skier to go through dangerous paths, by reaching high speed and endangering himself and the other customers. Here, a path is called dangerous, if it consists of at least two tracks.
Arthur wants to secure his customers by closing some of the spots in a way that there are no dangerous paths in the resort. When a spot is closed, all tracks entering and leaving that spot become unusable.
Formally, after closing some of the spots, there should not be a path that consists of two or more tracks.
Arthur doesn't want to close too many spots. He will be happy to find any way to close at most $\frac{4}{7}n$ spots so that the remaining part is safe. Help him find any suitable way to do so.
-----Input-----
The first line contains a single positive integer $T$Β β the number of test cases. $T$ test case description follows.
The first line of each description contains two integers $n$ and $m$ ($1 \leq n \leq 2 \cdot 10^5$)Β β the number of landing spots and tracks respectively.
The following $m$ lines describe the tracks. Each of these lines contains two integers $x$ and $y$ ($1 \leq x < y \leq n$)Β β indices of the starting and finishing spots for the respective track. It is guaranteed that at most two tracks start at each spot. There may be tracks in which starting and finishing spots both coincide.
It is guaranteed that the sum of $n$ over all test cases does not exceed $2 \cdot 10^5$.
-----Output-----
For each test case, print a single integer $k$ ($0 \leq k \leq \frac{4}{7}n$)Β β the number of spots to be closed. In the next line, print $k$ distinct integersΒ β indices of all spots to be closed, in any order.
If there are several answers, you may output any of them. Note that you don't have to minimize $k$. It can be shown that a suitable answer always exists.
-----Example-----
Input
2
4 6
1 2
1 3
2 3
2 4
3 4
3 4
7 6
1 2
1 3
2 4
2 5
3 6
3 7
Output
2
3 4
4
4 5 6 7
-----Note-----
In the first sample case, closing any two spots is suitable.
In the second sample case, closing only the spot $1$ is also suitable.
"""
| import sys
def nPZoD():
input = sys.stdin.readline
for f in range(int(input())):
n,m=list(map(int,input().split()))
neig=[0]*n
for i in range(n):
neig[i]=[0]
for i in range(m):
a,b=list(map(int,input().split()))
a-=1
b-=1
neig[a][0]+=1
neig[a].append(b)
lev=[1]*n
for i in range(n):
for j in range(1,neig[i][0]+1):
x=lev[i]+1
if x==4:
x=1
lev[neig[i][j]]=max(lev[neig[i][j]],x)
sol=0
s=[]
for i in range(n):
if lev[i]==3:
sol+=1
s.append(i+1)
print(sol)
print(*s)
| 2
4 6
1 2
1 3
2 3
2 4
3 4
3 4
7 6
1 2
1 3
2 4
2 5
3 6
3 7
| interview |
def WEQKe():
"""You like playing chess tournaments online.
In your last tournament you played $n$ games. For the sake of this problem, each chess game is either won or lost (no draws). When you lose a game you get $0$ points. When you win you get $1$ or $2$ points: if you have won also the previous game you get $2$ points, otherwise you get $1$ point. If you win the very first game of the tournament you get $1$ point (since there is not a "previous game").
The outcomes of the $n$ games are represented by a string $s$ of length $n$: the $i$-th character of $s$ is W if you have won the $i$-th game, while it is L if you have lost the $i$-th game.
After the tournament, you notice a bug on the website that allows you to change the outcome of at most $k$ of your games (meaning that at most $k$ times you can change some symbol L to W, or W to L). Since your only goal is to improve your chess rating, you decide to cheat and use the bug.
Compute the maximum score you can get by cheating in the optimal way.
-----Input-----
Each test contains multiple test cases. The first line contains an integer $t$ ($1\le t \le 20,000$) β the number of test cases. The description of the test cases follows.
The first line of each testcase contains two integers $n, k$ ($1\le n\le 100,000$, $0\le k\le n$) β the number of games played and the number of outcomes that you can change.
The second line contains a string $s$ of length $n$ containing only the characters W and L. If you have won the $i$-th game then $s_i=\,$W, if you have lost the $i$-th game then $s_i=\,$L.
It is guaranteed that the sum of $n$ over all testcases does not exceed $200,000$.
-----Output-----
For each testcase, print a single integer β the maximum score you can get by cheating in the optimal way.
-----Example-----
Input
8
5 2
WLWLL
6 5
LLLWWL
7 1
LWLWLWL
15 5
WWWLLLWWWLLLWWW
40 7
LLWLWLWWWLWLLWLWWWLWLLWLLWLLLLWLLWWWLWWL
1 0
L
1 1
L
6 1
WLLWLW
Output
7
11
6
26
46
0
1
6
-----Note-----
Explanation of the first testcase. Before changing any outcome, the score is $2$. Indeed, you won the first game, so you got $1$ point, and you won also the third, so you got another $1$ point (and not $2$ because you lost the second game).
An optimal way to cheat is to change the outcomes of the second and fourth game. Doing so, you end up winning the first four games (the string of the outcomes becomes WWWWL). Hence, the new score is $7=1+2+2+2$: $1$ point for the first game and $2$ points for the second, third and fourth game.
Explanation of the second testcase. Before changing any outcome, the score is $3$. Indeed, you won the fourth game, so you got $1$ point, and you won also the fifth game, so you got $2$ more points (since you won also the previous game).
An optimal way to cheat is to change the outcomes of the first, second, third and sixth game. Doing so, you end up winning all games (the string of the outcomes becomes WWWWWW). Hence, the new score is $11 = 1+2+2+2+2+2$: $1$ point for the first game and $2$ points for all the other games.
"""
| import sys
def WEQKe():
input = sys.stdin.readline
def main():
n, k = map(int, input().split())
string = input().strip()
if "W" not in string:
ans = min(n, k) * 2 - 1
print(max(ans, 0))
return
L_s = []
cnt = 0
bef = string[0]
ans = 0
for s in string:
if s == bef:
cnt += 1
else:
if bef == "L":
L_s.append(cnt)
else:
ans += cnt * 2 - 1
cnt = 1
bef = s
if bef == "W":
ans += cnt * 2 - 1
cnt = 0
if string[0] == "L" and L_s:
cnt += L_s[0]
L_s = L_s[1:]
L_s.sort()
for l in L_s:
if k >= l:
ans += l * 2 + 1
k -= l
else:
ans += k * 2
k = 0
ans += 2 * min(k, cnt)
print(ans)
for _ in range(int(input())):
main() | 8
5 2
WLWLL
6 5
LLLWWL
7 1
LWLWLWL
15 5
WWWLLLWWWLLLWWW
40 7
LLWLWLWWWLWLLWLWWWLWLLWLLWLLLLWLLWWWLWWL
1 0
L
1 1
L
6 1
WLLWLW
| interview |
def EPBXs():
"""Alice and Bob play a game. They have a binary string $s$ (a string such that each character in it is either $0$ or $1$). Alice moves first, then Bob, then Alice again, and so on.
During their move, the player can choose any number (not less than one) of consecutive equal characters in $s$ and delete them.
For example, if the string is $10110$, there are $6$ possible moves (deleted characters are bold): $\textbf{1}0110 \to 0110$; $1\textbf{0}110 \to 1110$; $10\textbf{1}10 \to 1010$; $101\textbf{1}0 \to 1010$; $10\textbf{11}0 \to 100$; $1011\textbf{0} \to 1011$.
After the characters are removed, the characters to the left and to the right of the removed block become adjacent. I. e. the following sequence of moves is valid: $10\textbf{11}0 \to 1\textbf{00} \to 1$.
The game ends when the string becomes empty, and the score of each player is the number of $1$-characters deleted by them.
Each player wants to maximize their score. Calculate the resulting score of Alice.
-----Input-----
The first line contains one integer $T$ ($1 \le T \le 500$) β the number of test cases.
Each test case contains exactly one line containing a binary string $s$ ($1 \le |s| \le 100$).
-----Output-----
For each test case, print one integer β the resulting score of Alice (the number of $1$-characters deleted by her).
-----Example-----
Input
5
01111001
0000
111111
101010101
011011110111
Output
4
0
6
3
6
-----Note-----
Questions about the optimal strategy will be ignored.
"""
|
def EPBXs():
for _ in range(int(input())):
s = input()
p = [i for i in s.split("0") if i!=""]
p.sort(reverse=True)
ans = 0
for i in range(0,len(p),2):
ans+=len(p[i])
print(ans)
| 5
01111001
0000
111111
101010101
011011110111
| interview |
def mjrXL():
"""Given a permutation $p$ of length $n$, find its subsequence $s_1$, $s_2$, $\ldots$, $s_k$ of length at least $2$ such that: $|s_1-s_2|+|s_2-s_3|+\ldots+|s_{k-1}-s_k|$ is as big as possible over all subsequences of $p$ with length at least $2$. Among all such subsequences, choose the one whose length, $k$, is as small as possible.
If multiple subsequences satisfy these conditions, you are allowed to find any of them.
A sequence $a$ is a subsequence of an array $b$ if $a$ can be obtained from $b$ by deleting some (possibly, zero or all) elements.
A permutation of length $n$ is an array of length $n$ in which every element from $1$ to $n$ occurs exactly once.
-----Input-----
The first line contains an integer $t$ ($1 \le t \le 2 \cdot 10^4$)Β β the number of test cases. The description of the test cases follows.
The first line of each test case contains an integer $n$ ($2 \le n \le 10^5$)Β β the length of the permutation $p$.
The second line of each test case contains $n$ integers $p_1$, $p_2$, $\ldots$, $p_{n}$ ($1 \le p_i \le n$, $p_i$ are distinct)Β β the elements of the permutation $p$.
The sum of $n$ across the test cases doesn't exceed $10^5$.
-----Output-----
For each test case, the first line should contain the length of the found subsequence, $k$. The second line should contain $s_1$, $s_2$, $\ldots$, $s_k$Β β its elements.
If multiple subsequences satisfy these conditions, you are allowed to find any of them.
-----Example-----
Input
2
3
3 2 1
4
1 3 4 2
Output
2
3 1
3
1 4 2
-----Note-----
In the first test case, there are $4$ subsequences of length at least $2$: $[3,2]$ which gives us $|3-2|=1$. $[3,1]$ which gives us $|3-1|=2$. $[2,1]$ which gives us $|2-1|=1$. $[3,2,1]$ which gives us $|3-2|+|2-1|=2$.
So the answer is either $[3,1]$ or $[3,2,1]$. Since we want the subsequence to be as short as possible, the answer is $[3,1]$.
"""
|
def mjrXL():
for _ in range(int(input())):
# n, x = map(int, input().split())
n = int(input())
arr = list(map(int, input().split()))
ans = [arr[0]]
for i in range(1, n - 1):
if arr[i - 1] < arr[i] and arr[i] > arr[i + 1]:
ans.append(arr[i])
elif arr[i - 1] > arr[i] and arr[i] < arr[i + 1]:
ans.append(arr[i])
ans.append(arr[-1])
print(len(ans))
print(*ans) | 2
3
3 2 1
4
1 3 4 2
| interview |
def WIPAo():
"""You have a string $s$ β a sequence of commands for your toy robot. The robot is placed in some cell of a rectangular grid. He can perform four commands: 'W' β move one cell up; 'S' β move one cell down; 'A' β move one cell left; 'D' β move one cell right.
Let $Grid(s)$ be the grid of minimum possible area such that there is a position in the grid where you can place the robot in such a way that it will not fall from the grid while running the sequence of commands $s$. For example, if $s = \text{DSAWWAW}$ then $Grid(s)$ is the $4 \times 3$ grid: you can place the robot in the cell $(3, 2)$; the robot performs the command 'D' and moves to $(3, 3)$; the robot performs the command 'S' and moves to $(4, 3)$; the robot performs the command 'A' and moves to $(4, 2)$; the robot performs the command 'W' and moves to $(3, 2)$; the robot performs the command 'W' and moves to $(2, 2)$; the robot performs the command 'A' and moves to $(2, 1)$; the robot performs the command 'W' and moves to $(1, 1)$. [Image]
You have $4$ extra letters: one 'W', one 'A', one 'S', one 'D'. You'd like to insert at most one of these letters in any position of sequence $s$ to minimize the area of $Grid(s)$.
What is the minimum area of $Grid(s)$ you can achieve?
-----Input-----
The first line contains one integer $T$ ($1 \le T \le 1000$) β the number of queries.
Next $T$ lines contain queries: one per line. This line contains single string $s$ ($1 \le |s| \le 2 \cdot 10^5$, $s_i \in \{\text{W}, \text{A}, \text{S}, \text{D}\}$) β the sequence of commands.
It's guaranteed that the total length of $s$ over all queries doesn't exceed $2 \cdot 10^5$.
-----Output-----
Print $T$ integers: one per query. For each query print the minimum area of $Grid(s)$ you can achieve.
-----Example-----
Input
3
DSAWWAW
D
WA
Output
8
2
4
-----Note-----
In the first query you have to get string $\text{DSAWW}\underline{D}\text{AW}$.
In second and third queries you can not decrease the area of $Grid(s)$.
"""
|
def WIPAo():
n = int(input())
def area(width, height) :
return (width+1) * (height+1)
def calcul(s1, c, s2) :
maxx, maxy, minx, miny = 0, 0, 0, 0
x, y = 0, 0
for k in range(len(s1)) :
if s1[k] == "W" :
y += 1
if s1[k] == "S" :
y -= 1
if s1[k] == "A" :
x -= 1
if s1[k] == "D" :
x += 1
maxx = max(maxx, x)
minx = min(minx, x)
maxy = max(maxy, y)
miny = min(miny, y)
if c == "W" :
y += 1
elif c == "S" :
y -= 1
elif c == "A" :
x -= 1
elif c == "D" :
x += 1
else :
print(c, "ok")
maxx = max(maxx, x)
minx = min(minx, x)
maxy = max(maxy, y)
miny = min(miny, y)
for k in range(len(s2)) :
if s2[k] == "W" :
y += 1
if s2[k] == "S" :
y -= 1
if s2[k] == "A" :
x -= 1
if s2[k] == "D" :
x += 1
maxx = max(maxx, x)
minx = min(minx, x)
maxy = max(maxy, y)
miny = min(miny, y)
diffx = maxx - minx
diffy = maxy - miny
tmp = area(diffx, diffy)
return tmp
def pre_calcul(s, moment, pre_avant, date_debut) :
x, y, maxx, minx, maxy, miny = pre_avant
for k in range(date_debut, moment) :
if s[k] == "W" :
y += 1
if s[k] == "S" :
y -= 1
if s[k] == "A" :
x -= 1
if s[k] == "D" :
x += 1
maxx = max(maxx, x)
minx = min(minx, x)
maxy = max(maxy, y)
miny = min(miny, y)
return (x, y, maxx, minx, maxy, miny)
def calcul2(s, c, moment, precalcul) :
x, y, maxx, minx, maxy, miny = precalcul
if c == "W" :
y += 1
elif c == "S" :
y -= 1
elif c == "A" :
x -= 1
elif c == "D" :
x += 1
else :
print(c, "ok")
maxx = max(maxx, x)
minx = min(minx, x)
maxy = max(maxy, y)
miny = min(miny, y)
for k in range(moment, len(s)) :
if s[k] == "W" :
y += 1
if s[k] == "S" :
y -= 1
if s[k] == "A" :
x -= 1
if s[k] == "D" :
x += 1
maxx = max(maxx, x)
minx = min(minx, x)
maxy = max(maxy, y)
miny = min(miny, y)
diffx = maxx - minx
diffy = maxy - miny
tmp = area(diffx, diffy)
return tmp
for _ in range(n) :
s = input()
maxx, maxy, minx, miny = 0, 0, 0, 0
x, y = 0, 0
momentminx, momentmaxx, momentminy, momentmaxy = -1, -1, -1, -1
for k in range(len(s)) :
if s[k] == "W" :
y += 1
if s[k] == "S" :
y -= 1
if s[k] == "A" :
x -= 1
if s[k] == "D" :
x += 1
if x > maxx :
momentmaxx = k
if y > maxy :
momentmaxy = k
if x < minx :
momentminx = k
if y < miny :
momentminy = k
maxx = max(maxx, x)
minx = min(minx, x)
maxy = max(maxy, y)
miny = min(miny, y)
diffx = maxx - minx
diffy = maxy - miny
tmp = 999999999999999999999999999999999999
l = [momentmaxx, momentmaxy, momentminx, momentminy]
l = list(set(l))
l = [i for i in l if i != -1]
l.sort()
if l != [] :
precalcul = pre_calcul(s, l[0], (0, 0, 0, 0, 0, 0), 0)
avant = l[0]
for moment in l :
precalcul = pre_calcul(s, moment, precalcul, avant)
avant = moment
tmp = min(tmp, calcul2(s, 'W', moment, precalcul))
tmp = min(tmp, calcul2(s, 'S', moment, precalcul))
tmp = min(tmp, calcul2(s, 'A', moment, precalcul))
tmp = min(tmp, calcul2(s, 'D', moment, precalcul))
print(tmp)
| 3
DSAWWAW
D
WA
| interview |
def OZyvC():
"""Once again, Boris needs the help of Anton in creating a task. This time Anton needs to solve the following problem:
There are two arrays of integers $a$ and $b$ of length $n$. It turned out that array $a$ contains only elements from the set $\{-1, 0, 1\}$.
Anton can perform the following sequence of operations any number of times: Choose any pair of indexes $(i, j)$ such that $1 \le i < j \le n$. It is possible to choose the same pair $(i, j)$ more than once. Add $a_i$ to $a_j$. In other words, $j$-th element of the array becomes equal to $a_i + a_j$.
For example, if you are given array $[1, -1, 0]$, you can transform it only to $[1, -1, -1]$, $[1, 0, 0]$ and $[1, -1, 1]$ by one operation.
Anton wants to predict if it is possible to apply some number (zero or more) of these operations to the array $a$ so that it becomes equal to array $b$. Can you help him?
-----Input-----
Each test contains multiple test cases.
The first line contains the number of test cases $t$ ($1 \le t \le 10000$). The 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 arrays.
The second line of each test case contains $n$ integers $a_1, a_2, \dots, a_n$ ($-1 \le a_i \le 1$) Β β elements of array $a$. There can be duplicates among elements.
The third line of each test case contains $n$ integers $b_1, b_2, \dots, b_n$ ($-10^9 \le b_i \le 10^9$) Β β elements of array $b$. There can be duplicates among elements.
It is guaranteed that the sum of $n$ over all test cases doesn't exceed $10^5$.
-----Output-----
For each test case, output one line containing "YES" if it's possible to make arrays $a$ and $b$ equal by performing the described operations, or "NO" if it's impossible.
You can print each letter in any case (upper or lower).
-----Example-----
Input
5
3
1 -1 0
1 1 -2
3
0 1 1
0 2 2
2
1 0
1 41
2
-1 0
-1 -41
5
0 1 -1 1 -1
1 1 -1 1 -1
Output
YES
NO
YES
YES
NO
-----Note-----
In the first test-case we can choose $(i, j)=(2, 3)$ twice and after that choose $(i, j)=(1, 2)$ twice too. These operations will transform $[1, -1, 0] \to [1, -1, -2] \to [1, 1, -2]$
In the second test case we can't make equal numbers on the second position.
In the third test case we can choose $(i, j)=(1, 2)$ $41$ times. The same about the fourth test case.
In the last lest case, it is impossible to make array $a$ equal to the array $b$.
"""
| from math import *
def OZyvC():
mod = 1000000007
for zz in range(int(input())):
n = int(input())
a = [ int(i) for i in input().split()]
b = [int(i) for i in input().split()]
ha = True
hp = False
hm = False
for i in range(n):
if b[i] != a[i]:
if b[i] > a[i]:
if (hp):
pass
else:
ha = False
break
else:
if (hm):
pass
else:
ha = False
break
if a[i] > 0:
hp = True
elif a[i] < 0:
hm = True
if ha:
print('YES')
else:
print('NO') | 5
3
1 -1 0
1 1 -2
3
0 1 1
0 2 2
2
1 0
1 41
2
-1 0
-1 -41
5
0 1 -1 1 -1
1 1 -1 1 -1
| interview |
def ybuqo():
"""Your company was appointed to lay new asphalt on the highway of length $n$. You know that every day you can either repair one unit of the highway (lay new asphalt over one unit of the highway) or skip repairing.
Skipping the repair is necessary because of the climate. The climate in your region is periodical: there are $g$ days when the weather is good and if you lay new asphalt these days it becomes high-quality pavement; after that, the weather during the next $b$ days is bad, and if you lay new asphalt these days it becomes low-quality pavement; again $g$ good days, $b$ bad days and so on.
You can be sure that you start repairing at the start of a good season, in other words, days $1, 2, \dots, g$ are good.
You don't really care about the quality of the highway, you just want to make sure that at least half of the highway will have high-quality pavement. For example, if the $n = 5$ then at least $3$ units of the highway should have high quality; if $n = 4$ then at least $2$ units should have high quality.
What is the minimum number of days is needed to finish the repair of the whole highway?
-----Input-----
The first line contains a single integer $T$ ($1 \le T \le 10^4$) β the number of test cases.
Next $T$ lines contain test cases β one per line. Each line contains three integers $n$, $g$ and $b$ ($1 \le n, g, b \le 10^9$) β the length of the highway and the number of good and bad days respectively.
-----Output-----
Print $T$ integers β one per test case. For each test case, print the minimum number of days required to repair the whole highway if at least half of it should have high quality.
-----Example-----
Input
3
5 1 1
8 10 10
1000000 1 1000000
Output
5
8
499999500000
-----Note-----
In the first test case, you can just lay new asphalt each day, since days $1, 3, 5$ are good.
In the second test case, you can also lay new asphalt each day, since days $1$-$8$ are good.
"""
|
def ybuqo():
for i in range(int(input())):
n,g,b=map(int,input().split())
nn=(n+1)//2
print(max(nn+(nn-1)//g*b,n)) | 3
5 1 1
8 10 10
1000000 1 1000000
| interview |
def sVUNl():
"""Vasya claims that he had a paper square. He cut it into two rectangular parts using one vertical or horizontal cut. Then Vasya informed you the dimensions of these two rectangular parts. You need to check whether Vasya originally had a square. In other words, check if it is possible to make a square using two given rectangles.
-----Input-----
The first line contains an integer $t$ ($1 \le t \le 10^4$) β the number of test cases in the input. Then $t$ test cases follow.
Each test case is given in two lines.
The first line contains two integers $a_1$ and $b_1$ ($1 \le a_1, b_1 \le 100$) β the dimensions of the first one obtained after cutting rectangle. The sizes are given in random order (that is, it is not known which of the numbers is the width, and which of the numbers is the length).
The second line contains two integers $a_2$ and $b_2$ ($1 \le a_2, b_2 \le 100$) β the dimensions of the second obtained after cutting rectangle. The sizes are given in random order (that is, it is not known which of the numbers is the width, and which of the numbers is the length).
-----Output-----
Print $t$ answers, each of which is a string "YES" (in the case of a positive answer) or "NO" (in the case of a negative answer). The letters in words can be printed in any case (upper or lower).
-----Example-----
Input
3
2 3
3 1
3 2
1 3
3 3
1 3
Output
Yes
Yes
No
"""
|
def sVUNl():
for _ in range(int(input())):
a1, b1 = list(map(int, input().split()))
a2, b2 = list(map(int, input().split()))
if a1 > b1:
a1, b1 = b1, a1
if a2 > b2:
a2, b2 = b2, a2
flag = False
if a1 == a2 and a1 == b1 + b2:
flag = True
if b1 == b2 and b1 == a1 + a2:
flag = True
print('Yes' if flag else 'No')
| 3
2 3
3 1
3 2
1 3
3 3
1 3
| interview |
def cQPoi():
"""Screen resolution of Polycarp's monitor is $a \times b$ pixels. Unfortunately, there is one dead pixel at his screen. It has coordinates $(x, y)$ ($0 \le x < a, 0 \le y < b$). You can consider columns of pixels to be numbered from $0$ to $a-1$, and rowsΒ β from $0$ to $b-1$.
Polycarp wants to open a rectangular window of maximal size, which doesn't contain the dead pixel. The boundaries of the window should be parallel to the sides of the screen.
Print the maximal area (in pixels) of a window that doesn't contain the dead pixel inside itself.
-----Input-----
In the first line you are given an integer $t$ ($1 \le t \le 10^4$)Β β the number of test cases in the test. In the next lines you are given descriptions of $t$ test cases.
Each test case contains a single line which consists of $4$ integers $a, b, x$ and $y$ ($1 \le a, b \le 10^4$; $0 \le x < a$; $0 \le y < b$)Β β the resolution of the screen and the coordinates of a dead pixel. It is guaranteed that $a+b>2$ (e.g. $a=b=1$ is impossible).
-----Output-----
Print $t$ integersΒ β the answers for each test case. Each answer should contain an integer equal to the maximal possible area (in pixels) of a rectangular window, that doesn't contain the dead pixel.
-----Example-----
Input
6
8 8 0 0
1 10 0 3
17 31 10 4
2 1 0 0
5 10 3 9
10 10 4 8
Output
56
6
442
1
45
80
-----Note-----
In the first test case, the screen resolution is $8 \times 8$, and the upper left pixel is a dead pixel. Here you can see one of two possible layouts of the maximal window. [Image]
"""
| from math import *
def cQPoi():
zzz = int(input())
for zz in range(zzz):
a, b, x, y = list(map(int, input().split()))
print(max(x*b, (a-x-1)*b, y*a, (b - y - 1)*a)) | 6
8 8 0 0
1 10 0 3
17 31 10 4
2 1 0 0
5 10 3 9
10 10 4 8
| interview |
def VGDCf():
"""The statement of this problem is the same as the statement of problem C2. The only difference is that, in problem C1, $n$ is always even, and in C2, $n$ is always odd.
You are given a regular polygon with $2 \cdot n$ vertices (it's convex and has equal sides and equal angles) and all its sides have length $1$. Let's name it as $2n$-gon.
Your task is to find the square of the minimum size such that you can embed $2n$-gon in the square. Embedding $2n$-gon in the square means that you need to place $2n$-gon in the square in such way that each point which lies inside or on a border of $2n$-gon should also lie inside or on a border of the square.
You can rotate $2n$-gon and/or the square.
-----Input-----
The first line contains a single integer $T$ ($1 \le T \le 200$)Β β the number of test cases.
Next $T$ lines contain descriptions of test casesΒ β one per line. Each line contains single even integer $n$ ($2 \le n \le 200$). Don't forget you need to embed $2n$-gon, not an $n$-gon.
-----Output-----
Print $T$ real numbersΒ β one per test case. For each test case, print the minimum length of a side of the square $2n$-gon can be embedded in. Your answer will be considered correct if its absolute or relative error doesn't exceed $10^{-6}$.
-----Example-----
Input
3
2
4
200
Output
1.000000000
2.414213562
127.321336469
"""
| import math
def VGDCf():
T = int(input())
for _ in range(T):
n = int(input())
print(1/math.tan(math.pi/2/n)) | 3
2
4
200
| interview |
def IMgfD():
"""The only difference between easy and hard versions is constraints.
The BerTV channel every day broadcasts one episode of one of the $k$ TV shows. You know the schedule for the next $n$ days: a sequence of integers $a_1, a_2, \dots, a_n$ ($1 \le a_i \le k$), where $a_i$ is the show, the episode of which will be shown in $i$-th day.
The subscription to the show is bought for the entire show (i.e. for all its episodes), for each show the subscription is bought separately.
How many minimum subscriptions do you need to buy in order to have the opportunity to watch episodes of purchased shows $d$ ($1 \le d \le n$) days in a row? In other words, you want to buy the minimum number of TV shows so that there is some segment of $d$ consecutive days in which all episodes belong to the purchased shows.
-----Input-----
The first line contains an integer $t$ ($1 \le t \le 10000$) β the number of test cases in the input. Then $t$ test case descriptions follow.
The first line of each test case contains three integers $n, k$ and $d$ ($1 \le n \le 2\cdot10^5$, $1 \le k \le 10^6$, $1 \le d \le n$). The second line contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \le a_i \le k$), where $a_i$ is the show that is broadcasted on the $i$-th day.
It is guaranteed that the sum of the values ββof $n$ for all test cases in the input does not exceed $2\cdot10^5$.
-----Output-----
Print $t$ integers β the answers to the test cases in the input in the order they follow. The answer to a test case is the minimum number of TV shows for which you need to purchase a subscription so that you can watch episodes of the purchased TV shows on BerTV for $d$ consecutive days. Please note that it is permissible that you will be able to watch more than $d$ days in a row.
-----Example-----
Input
4
5 2 2
1 2 1 2 1
9 3 3
3 3 3 2 2 2 1 1 1
4 10 4
10 8 6 4
16 9 8
3 1 4 1 5 9 2 6 5 3 5 8 9 7 9 3
Output
2
1
4
5
-----Note-----
In the first test case to have an opportunity to watch shows for two consecutive days, you need to buy a subscription on show $1$ and on show $2$. So the answer is two.
In the second test case, you can buy a subscription to any show because for each show you can find a segment of three consecutive days, consisting only of episodes of this show.
In the third test case in the unique segment of four days, you have four different shows, so you need to buy a subscription to all these four shows.
In the fourth test case, you can buy subscriptions to shows $3,5,7,8,9$, and you will be able to watch shows for the last eight days.
"""
|
def IMgfD():
for _ in range(int(input())):
n, k, d = list(map(int, input().split()))
a = list(map(int, input().split()))
s = {}
for q in range(d):
s[a[q]] = s.get(a[q], 0)+1
ans = len(s)
for q in range(d, n):
if s[a[q-d]] == 1:
del s[a[q-d]]
else:
s[a[q-d]] -= 1
s[a[q]] = s.get(a[q], 0)+1
ans = min(ans, len(s))
print(ans)
| 4
5 2 2
1 2 1 2 1
9 3 3
3 3 3 2 2 2 1 1 1
4 10 4
10 8 6 4
16 9 8
3 1 4 1 5 9 2 6 5 3 5 8 9 7 9 3
| interview |
def dTnRU():
"""Gildong owns a bulgogi restaurant. The restaurant has a lot of customers, so many of them like to make a reservation before visiting it.
Gildong tries so hard to satisfy the customers that he even memorized all customers' preferred temperature ranges! Looking through the reservation list, he wants to satisfy all customers by controlling the temperature of the restaurant.
The restaurant has an air conditioner that has 3 states: off, heating, and cooling. When it's off, the restaurant's temperature remains the same. When it's heating, the temperature increases by 1 in one minute. Lastly, when it's cooling, the temperature decreases by 1 in one minute. Gildong can change the state as many times as he wants, at any integer minutes. The air conditioner is off initially.
Each customer is characterized by three values: $t_i$ β the time (in minutes) when the $i$-th customer visits the restaurant, $l_i$ β the lower bound of their preferred temperature range, and $h_i$ β the upper bound of their preferred temperature range.
A customer is satisfied if the temperature is within the preferred range at the instant they visit the restaurant. Formally, the $i$-th customer is satisfied if and only if the temperature is between $l_i$ and $h_i$ (inclusive) in the $t_i$-th minute.
Given the initial temperature, the list of reserved customers' visit times and their preferred temperature ranges, you're going to help him find if it's possible to satisfy all customers.
-----Input-----
Each test contains one or more test cases. The first line contains the number of test cases $q$ ($1 \le q \le 500$). Description of the test cases follows.
The first line of each test case contains two integers $n$ and $m$ ($1 \le n \le 100$, $-10^9 \le m \le 10^9$), where $n$ is the number of reserved customers and $m$ is the initial temperature of the restaurant.
Next, $n$ lines follow. The $i$-th line of them contains three integers $t_i$, $l_i$, and $h_i$ ($1 \le t_i \le 10^9$, $-10^9 \le l_i \le h_i \le 10^9$), where $t_i$ is the time when the $i$-th customer visits, $l_i$ is the lower bound of their preferred temperature range, and $h_i$ is the upper bound of their preferred temperature range. The preferred temperature ranges are inclusive.
The customers are given in non-decreasing order of their visit time, and the current time is $0$.
-----Output-----
For each test case, print "YES" if it is possible to satisfy all customers. Otherwise, print "NO".
You can print each letter in any case (upper or lower).
-----Example-----
Input
4
3 0
5 1 2
7 3 5
10 -1 0
2 12
5 7 10
10 16 20
3 -100
100 0 0
100 -50 50
200 100 100
1 100
99 -100 0
Output
YES
NO
YES
NO
-----Note-----
In the first case, Gildong can control the air conditioner to satisfy all customers in the following way: At $0$-th minute, change the state to heating (the temperature is 0). At $2$-nd minute, change the state to off (the temperature is 2). At $5$-th minute, change the state to heating (the temperature is 2, the $1$-st customer is satisfied). At $6$-th minute, change the state to off (the temperature is 3). At $7$-th minute, change the state to cooling (the temperature is 3, the $2$-nd customer is satisfied). At $10$-th minute, the temperature will be 0, which satisfies the last customer.
In the third case, Gildong can change the state to heating at $0$-th minute and leave it be. Then all customers will be satisfied. Note that the $1$-st customer's visit time equals the $2$-nd customer's visit time.
In the second and the fourth case, Gildong has to make at least one customer unsatisfied.
"""
|
def dTnRU():
q = int(input())
for _ in range(q):
n, m = list(map(int, input().split()))
info = [list(map(int, input().split())) for i in range(n)]
info = sorted(info)
now =(m, m)
time = 0
flag = True
for i in range(n):
t, l, h = info[i]
l_now = now[0] - (t - time)
h_now = now[1] + (t - time)
time = t
if h < l_now or h_now < l:
flag = False
else:
l_now = max(l_now, l)
h_now = min(h_now, h)
now = (l_now, h_now)
if flag:
print("YES")
else:
print("NO") | 4
3 0
5 1 2
7 3 5
10 -1 0
2 12
5 7 10
10 16 20
3 -100
100 0 0
100 -50 50
200 100 100
1 100
99 -100 0
| interview |
def aVngC():
"""Among Johnny's numerous hobbies, there are two seemingly harmless ones: applying bitwise operations and sneaking into his dad's office. As it is usually the case with small children, Johnny is unaware that combining these two activities can get him in a lot of trouble.
There is a set $S$ containing very important numbers on his dad's desk. The minute Johnny heard about it, he decided that it's a good idea to choose a positive integer $k$ and replace each element $s$ of the set $S$ with $s \oplus k$ ($\oplus$ denotes the exclusive or operation).
Help him choose such $k$ that Johnny's dad will not see any difference after his son is done playing (i.e. Johnny will get the same set as before playing). It is possible that no such number exists. It is also possible that there are many of them. In such a case, output the smallest one. Note that the order of elements in a set doesn't matter, i.e. set $\{1, 2, 3\}$ equals to set $\{2, 1, 3\}$.
Formally, find the smallest positive integer $k$ such that $\{s \oplus k | s \in S\} = S$ or report that there is no such number.
For example, if $S = \{1, 3, 4\}$ and $k = 2$, new set will be equal to $\{3, 1, 6\}$. If $S = \{0, 1, 2, 3\}$ and $k = 1$, after playing set will stay the same.
-----Input-----
In the first line of input, there is a single integer $t$ ($1 \leq t \leq 1024$), the number of test cases. In the next lines, $t$ test cases follow. Each of them consists of two lines.
In the first line there is a single integer $n$ ($1 \leq n \leq 1024$) denoting the number of elements in set $S$. Second line consists of $n$ distinct integers $s_i$ ($0 \leq s_i < 1024$), elements of $S$.
It is guaranteed that the sum of $n$ over all test cases will not exceed $1024$.
-----Output-----
Print $t$ lines; $i$-th line should contain the answer to the $i$-th test case, the minimal positive integer $k$ satisfying the conditions or $-1$ if no such $k$ exists.
-----Example-----
Input
6
4
1 0 2 3
6
10 7 14 8 3 12
2
0 2
3
1 2 3
6
1 4 6 10 11 12
2
0 1023
Output
1
4
2
-1
-1
1023
-----Note-----
In the first test case, the answer is $1$ because it is a minimum positive integer and it satisfies all the conditions.
"""
|
def aVngC():
t = int(input())
for _ in range(t):
n = list(input().strip())
s = list(map(int, input().strip().split()))
check = set(s)
found = False
for i in range(1, 1025):
newset = set([e^i for e in s])
if check == newset:
print(i)
found = True
break
if not found:
print(-1)
| 6
4
1 0 2 3
6
10 7 14 8 3 12
2
0 2
3
1 2 3
6
1 4 6 10 11 12
2
0 1023
| interview |
def eyFHi():
"""Let's define the following recurrence: $$a_{n+1} = a_{n} + minDigit(a_{n}) \cdot maxDigit(a_{n}).$$
Here $minDigit(x)$ and $maxDigit(x)$ are the minimal and maximal digits in the decimal representation of $x$ without leading zeroes. For examples refer to notes.
Your task is calculate $a_{K}$ for given $a_{1}$ and $K$.
-----Input-----
The first line contains one integer $t$ ($1 \le t \le 1000$)Β β the number of independent test cases.
Each test case consists of a single line containing two integers $a_{1}$ and $K$ ($1 \le a_{1} \le 10^{18}$, $1 \le K \le 10^{16}$) separated by a space.
-----Output-----
For each test case print one integer $a_{K}$ on a separate line.
-----Example-----
Input
8
1 4
487 1
487 2
487 3
487 4
487 5
487 6
487 7
Output
42
487
519
528
544
564
588
628
-----Note-----
$a_{1} = 487$
$a_{2} = a_{1} + minDigit(a_{1}) \cdot maxDigit(a_{1}) = 487 + \min (4, 8, 7) \cdot \max (4, 8, 7) = 487 + 4 \cdot 8 = 519$
$a_{3} = a_{2} + minDigit(a_{2}) \cdot maxDigit(a_{2}) = 519 + \min (5, 1, 9) \cdot \max (5, 1, 9) = 519 + 1 \cdot 9 = 528$
$a_{4} = a_{3} + minDigit(a_{3}) \cdot maxDigit(a_{3}) = 528 + \min (5, 2, 8) \cdot \max (5, 2, 8) = 528 + 2 \cdot 8 = 544$
$a_{5} = a_{4} + minDigit(a_{4}) \cdot maxDigit(a_{4}) = 544 + \min (5, 4, 4) \cdot \max (5, 4, 4) = 544 + 4 \cdot 5 = 564$
$a_{6} = a_{5} + minDigit(a_{5}) \cdot maxDigit(a_{5}) = 564 + \min (5, 6, 4) \cdot \max (5, 6, 4) = 564 + 4 \cdot 6 = 588$
$a_{7} = a_{6} + minDigit(a_{6}) \cdot maxDigit(a_{6}) = 588 + \min (5, 8, 8) \cdot \max (5, 8, 8) = 588 + 5 \cdot 8 = 628$
"""
| import sys
def eyFHi():
input = sys.stdin.readline
for _ in range(int(input())):
a, k = list(map(int, input().split()))
for _ in range(k - 1):
if '0' in str(a):
break
a += int(min(list(str(a)))) * int(max(list(str(a))))
print(a) | 8
1 4
487 1
487 2
487 3
487 4
487 5
487 6
487 7
| interview |
def BgxPQ():
"""The only difference between easy and hard versions is constraints.
Now elections are held in Berland and you want to win them. More precisely, you want everyone to vote for you.
There are $n$ voters, and two ways to convince each of them to vote for you. The first way to convince the $i$-th voter is to pay him $p_i$ coins. The second way is to make $m_i$ other voters vote for you, and the $i$-th voter will vote for free.
Moreover, the process of such voting takes place in several steps. For example, if there are five voters with $m_1 = 1$, $m_2 = 2$, $m_3 = 2$, $m_4 = 4$, $m_5 = 5$, then you can buy the vote of the fifth voter, and eventually everyone will vote for you. Set of people voting for you will change as follows: ${5} \rightarrow {1, 5} \rightarrow {1, 2, 3, 5} \rightarrow {1, 2, 3, 4, 5}$.
Calculate the minimum number of coins you have to spend so that everyone votes for you.
-----Input-----
The first line contains one integer $t$ ($1 \le t \le 5000$) β the number of test cases.
The first line of each test case contains one integer $n$ ($1 \le n \le 5000$) β the number of voters.
The next $n$ lines contains the description of voters. $i$-th line contains two integers $m_i$ and $p_i$ ($1 \le p_i \le 10^9, 0 \le m_i < n$).
It is guaranteed that the sum of all $n$ over all test cases does not exceed $5000$.
-----Output-----
For each test case print one integer β the minimum number of coins you have to spend so that everyone votes for you.
-----Example-----
Input
3
3
1 5
2 10
2 8
7
0 1
3 1
1 1
6 1
1 1
4 1
4 1
6
2 6
2 3
2 8
2 7
4 4
5 5
Output
8
0
7
-----Note-----
In the first test case you have to buy vote of the third voter. Then the set of people voting for you will change as follows: ${3} \rightarrow {1, 3} \rightarrow {1, 2, 3}$.
In the second example you don't need to buy votes. The set of people voting for you will change as follows: ${1} \rightarrow {1, 3, 5} \rightarrow {1, 2, 3, 5} \rightarrow {1, 2, 3, 5, 6, 7} \rightarrow {1, 2, 3, 4, 5, 6, 7}$.
In the third test case you have to buy votes of the second and the fifth voters. Then the set of people voting for you will change as follows: ${2, 5} \rightarrow {1, 2, 3, 4, 5} \rightarrow {1, 2, 3, 4, 5, 6}$.
"""
| import heapq
def BgxPQ():
for _ in range(int(input())):
n = int(input())
voters = []
for i in range(n):
m,p = list(map(int, input().split()))
voters.append((m, -p))
voters.sort()
for i in range(n):
voters[i] = (voters[i][0], -voters[i][1])
ans = 0
costs = []
heapq.heapify(costs)
bought = 0
for i in range(n-1, -1, -1):
buysNeeded = voters[i][0] - i - bought
heapq.heappush(costs, voters[i][1])
while buysNeeded > 0 and len(costs) > 0:
ans += heapq.heappop(costs)
bought += 1
buysNeeded -= 1
print(ans) | 3
3
1 5
2 10
2 8
7
0 1
3 1
1 1
6 1
1 1
4 1
4 1
6
2 6
2 3
2 8
2 7
4 4
5 5
| interview |
def KrEdx():
"""Try guessing the statement from this picture: $3$
You are given a non-negative integer $d$. You have to find two non-negative real numbers $a$ and $b$ such that $a + b = d$ and $a \cdot b = d$.
-----Input-----
The first line contains $t$ ($1 \le t \le 10^3$) β the number of test cases.
Each test case contains one integer $d$ $(0 \le d \le 10^3)$.
-----Output-----
For each test print one line.
If there is an answer for the $i$-th test, print "Y", and then the numbers $a$ and $b$.
If there is no answer for the $i$-th test, print "N".
Your answer will be considered correct if $|(a + b) - a \cdot b| \le 10^{-6}$ and $|(a + b) - d| \le 10^{-6}$.
-----Example-----
Input
7
69
0
1
4
5
999
1000
Output
Y 67.985071301 1.014928699
Y 0.000000000 0.000000000
N
Y 2.000000000 2.000000000
Y 3.618033989 1.381966011
Y 997.998996990 1.001003010
Y 998.998997995 1.001002005
"""
|
def KrEdx():
for _ in range(int(input())):
d=int(input())
anws=False
if d**2>=4*d:
root=(d**2-4*d)**0.5
a=(d+root)/2
b=(d-root)/2
anws=True
if anws:
print("Y {:.9f} {:.9f}".format(a,b))
else:
print("N") | 7
69
0
1
4
5
999
1000
| interview |
def jhTZQ():
"""You are given a special jigsaw puzzle consisting of $n\cdot m$ identical pieces. Every piece has three tabs and one blank, as pictured below. $\{3$
The jigsaw puzzle is considered solved if the following conditions hold: The pieces are arranged into a grid with $n$ rows and $m$ columns. For any two pieces that share an edge in the grid, a tab of one piece fits perfectly into a blank of the other piece.
Through rotation and translation of the pieces, determine if it is possible to solve the jigsaw puzzle.
-----Input-----
The test consists of multiple test cases. The first line contains a single integer $t$ ($1\le t\le 1000$)Β β the number of test cases. Next $t$ lines contain descriptions of test cases.
Each test case contains two integers $n$ and $m$ ($1 \le n,m \le 10^5$).
-----Output-----
For each test case output a single line containing "YES" if it is possible to solve the jigsaw puzzle, or "NO" otherwise. You can print each letter in any case (upper or lower).
-----Example-----
Input
3
1 3
100000 100000
2 2
Output
YES
NO
YES
-----Note-----
For the first test case, this is an example solution: [Image]
For the second test case, we can show that no solution exists.
For the third test case, this is an example solution: $\left\{\begin{array}{l}{3} \\{3} \end{array} \right\}$
"""
|
def jhTZQ():
for _ in range(int(input())):
n, m = list(map(int, input().split()))
if n < m:
n, m = m, n # n > m
if m == 1:
print("YES")
continue
if m == 2 and n == 2:
print("YES")
continue
print("NO")
| 3
1 3
100000 100000
2 2
| interview |
def ohNuK():
"""There are $n$ positive integers $a_1, a_2, \dots, a_n$. For the one move you can choose any even value $c$ and divide by two all elements that equal $c$.
For example, if $a=[6,8,12,6,3,12]$ and you choose $c=6$, and $a$ is transformed into $a=[3,8,12,3,3,12]$ after the move.
You need to find the minimal number of moves for transforming $a$ to an array of only odd integers (each element shouldn't be divisible by $2$).
-----Input-----
The first line of the input contains one integer $t$ ($1 \le t \le 10^4$) β the number of test cases in the input. Then $t$ test cases follow.
The first line of a test case contains $n$ ($1 \le n \le 2\cdot10^5$) β the number of integers in the sequence $a$. The second line contains positive integers $a_1, a_2, \dots, a_n$ ($1 \le a_i \le 10^9$).
The sum of $n$ for all test cases in the input doesn't exceed $2\cdot10^5$.
-----Output-----
For $t$ test cases print the answers in the order of test cases in the input. The answer for the test case is the minimal number of moves needed to make all numbers in the test case odd (i.e. not divisible by $2$).
-----Example-----
Input
4
6
40 6 40 3 20 1
1
1024
4
2 4 8 16
3
3 1 7
Output
4
10
4
0
-----Note-----
In the first test case of the example, the optimal sequence of moves can be as follows:
before making moves $a=[40, 6, 40, 3, 20, 1]$; choose $c=6$; now $a=[40, 3, 40, 3, 20, 1]$; choose $c=40$; now $a=[20, 3, 20, 3, 20, 1]$; choose $c=20$; now $a=[10, 3, 10, 3, 10, 1]$; choose $c=10$; now $a=[5, 3, 5, 3, 5, 1]$ β all numbers are odd.
Thus, all numbers became odd after $4$ moves. In $3$ or fewer moves, you cannot make them all odd.
"""
|
def ohNuK():
tests = int(input())
for test in range(tests):
n = int(input())
a = [int(i) for i in input().split()]
d = {}
for i in range(n):
s = 0
while a[i] % 2 == 0:
a[i] //= 2
s += 1
if a[i] in list(d.keys()):
d[a[i]] = max(s, d[a[i]])
else:
d[a[i]] = s
s = 0
for i in list(d.keys()):
s += d[i]
print(s)
| 4
6
40 6 40 3 20 1
1
1024
4
2 4 8 16
3
3 1 7
| interview |
def EGYhP():
"""Acacius is studying strings theory. Today he came with the following problem.
You are given a string $s$ of length $n$ consisting of lowercase English letters and question marks. It is possible to replace question marks with lowercase English letters in such a way that a string "abacaba" occurs as a substring in a resulting string exactly once?
Each question mark should be replaced with exactly one lowercase English letter. For example, string "a?b?c" can be transformed into strings "aabbc" and "azbzc", but can't be transformed into strings "aabc", "a?bbc" and "babbc".
Occurrence of a string $t$ of length $m$ in the string $s$ of length $n$ as a substring is a index $i$ ($1 \leq i \leq n - m + 1$) such that string $s[i..i+m-1]$ consisting of $m$ consecutive symbols of $s$ starting from $i$-th equals to string $t$. For example string "ababa" has two occurrences of a string "aba" as a substring with $i = 1$ and $i = 3$, but there are no occurrences of a string "aba" in the string "acba" as a substring.
Please help Acacius to check if it is possible to replace all question marks with lowercase English letters in such a way that a string "abacaba" occurs as a substring in a resulting string exactly once.
-----Input-----
First line of input contains an integer $T$ ($1 \leq T \leq 5000$), number of test cases. $T$ pairs of lines with test case descriptions follow.
The first line of a test case description contains a single integer $n$ ($7 \leq n \leq 50$), length of a string $s$.
The second line of a test case description contains string $s$ of length $n$ consisting of lowercase English letters and question marks.
-----Output-----
For each test case output an answer for it.
In case if there is no way to replace question marks in string $s$ with a lowercase English letters in such a way that there is exactly one occurrence of a string "abacaba" in the resulting string as a substring output "No".
Otherwise output "Yes" and in the next line output a resulting string consisting of $n$ lowercase English letters. If there are multiple possible strings, output any.
You may print every letter in "Yes" and "No" in any case you want (so, for example, the strings yEs, yes, Yes, and YES will all be recognized as positive answer).
-----Example-----
Input
6
7
abacaba
7
???????
11
aba?abacaba
11
abacaba?aba
15
asdf???f???qwer
11
abacabacaba
Output
Yes
abacaba
Yes
abacaba
Yes
abadabacaba
Yes
abacabadaba
No
No
-----Note-----
In first example there is exactly one occurrence of a string "abacaba" in the string "abacaba" as a substring.
In second example seven question marks can be replaced with any seven lowercase English letters and with "abacaba" in particular.
In sixth example there are two occurrences of a string "abacaba" as a substring.
"""
| import sys
from math import gcd
from math import ceil
from collections import defaultdict as dd, Counter
from bisect import bisect_left as bl, bisect_right as br
def EGYhP():
INF = 10**20
MOD = 10**9 + 7
I = lambda:list(map(int,input().split()))
"""
Facts and Data representation
Constructive? Top bottom up down
"""
def check(s):
t = 'abacaba'
ans = 0
for i in range(len(s)):
if s[i: i + 7] == t:
ans += 1
return ans
def solve():
n, = I()
s = input()
t = 'abacaba'
cnt = check(s)
if cnt > 1:
print('No')
return
elif cnt == 1:
s = list(s)
for i in range(n):
if s[i] == '?':
s[i] = 'z'
print('Yes')
print(''.join(s))
else:
s = list(s)
ok = s[::]
for i in range(n - 6):
ok = s[::]
for j in range(7):
if s[i + j] == t[j]:
continue
elif s[i + j] == '?':
ok[i + j] = t[j]
else:
break
else:
for i in range(n):
if ok[i] == '?':
ok[i] = 'z'
ok = ''.join(ok)
if check(ok) != 1:
continue
print('Yes')
print(ok)
return
print('No')
t, = I()
while t:
t -= 1
solve() | 6
7
abacaba
7
???????
11
aba?abacaba
11
abacaba?aba
15
asdf???f???qwer
11
abacabacaba
| interview |
def lYiRe():
"""You are given an array $a$ consisting of $n$ integers numbered from $1$ to $n$.
Let's define the $k$-amazing number of the array as the minimum number that occurs in all of the subsegments of the array having length $k$ (recall that a subsegment of $a$ of length $k$ is a contiguous part of $a$ containing exactly $k$ elements). If there is no integer occuring in all subsegments of length $k$ for some value of $k$, then the $k$-amazing number is $-1$.
For each $k$ from $1$ to $n$ calculate the $k$-amazing number of the array $a$.
-----Input-----
The first line contains one integer $t$ ($1 \le t \le 1000$) β the number of test cases. Then $t$ test cases follow.
The first line of each test case contains one integer $n$ ($1 \le n \le 3 \cdot 10^5$) β the number of elements in the array. The second line contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \le a_i \le n$) β the elements of the array.
It is guaranteed that the sum of $n$ over all test cases does not exceed $3 \cdot 10^5$.
-----Output-----
For each test case print $n$ integers, where the $i$-th integer is equal to the $i$-amazing number of the array.
-----Example-----
Input
3
5
1 2 3 4 5
5
4 4 4 4 2
6
1 3 1 5 3 1
Output
-1 -1 3 2 1
-1 4 4 4 2
-1 -1 1 1 1 1
"""
|
def lYiRe():
input=__import__('sys').stdin.readline
for _ in range(int(input())):
n=int(input())
s=list(map(int,input().split()))
g=[[-1]for _ in range(n+1)]
for i in range(n):
g[s[i]].append(i)
inf=10**10
ans=[-1]*n
lstunused=n
for i in range(1,n+1):
g[i].append(n)
mx=0
for j in range(1,len(g[i])):
mx=max(mx,g[i][j]-g[i][j-1]-1)
for j in range(mx,lstunused):
ans[j]=i
lstunused=min(lstunused,mx)
print(*ans) | 3
5
1 2 3 4 5
5
4 4 4 4 2
6
1 3 1 5 3 1
| interview |
def jEFZw():
"""You are given a string $s$ of even length $n$. String $s$ is binary, in other words, consists only of 0's and 1's.
String $s$ has exactly $\frac{n}{2}$ zeroes and $\frac{n}{2}$ ones ($n$ is even).
In one operation you can reverse any substring of $s$. A substring of a string is a contiguous subsequence of that string.
What is the minimum number of operations you need to make string $s$ alternating? A string is alternating if $s_i \neq s_{i + 1}$ for all $i$. There are two types of alternating strings in general: 01010101... or 10101010...
-----Input-----
The first line contains a single integer $t$ ($1 \le t \le 1000$)Β β the number of test cases.
The first line of each test case contains a single integer $n$ ($2 \le n \le 10^5$; $n$ is even)Β β the length of string $s$.
The second line of each test case contains a binary string $s$ of length $n$ ($s_i \in$ {0, 1}). String $s$ has exactly $\frac{n}{2}$ zeroes and $\frac{n}{2}$ ones.
It's guaranteed that the total sum of $n$ over test cases doesn't exceed $10^5$.
-----Output-----
For each test case, print the minimum number of operations to make $s$ alternating.
-----Example-----
Input
3
2
10
4
0110
8
11101000
Output
0
1
2
-----Note-----
In the first test case, string 10 is already alternating.
In the second test case, we can, for example, reverse the last two elements of $s$ and get: 0110 $\rightarrow$ 0101.
In the third test case, we can, for example, make the following two operations: 11101000 $\rightarrow$ 10101100; 10101100 $\rightarrow$ 10101010.
"""
|
def jEFZw():
t = int(input())
for i in range(t):
n = int(input())
s = input()
ans = 0
for y in range(1, n):
if s[y] == s[y-1]:
ans += 1
print((ans + ans % 2) // 2)
| 3
2
10
4
0110
8
11101000
| interview |
def JfYEb():
"""Skier rides on a snowy field. Its movements can be described by a string of characters 'S', 'N', 'W', 'E' (which correspond to $1$ meter movement in the south, north, west or east direction respectively).
It is known that if he moves along a previously unvisited segment of a path (i.e. this segment of the path is visited the first time), then the time of such movement is $5$ seconds. If he rolls along previously visited segment of a path (i.e., this segment of the path has been covered by his path before), then it takes $1$ second.
Find the skier's time to roll all the path.
-----Input-----
The first line contains an integer $t$ ($1 \le t \le 10^4$) β the number of test cases in the input. Then $t$ test cases follow.
Each set is given by one nonempty string of the characters 'S', 'N', 'W', 'E'. The length of the string does not exceed $10^5$ characters.
The sum of the lengths of $t$ given lines over all test cases in the input does not exceed $10^5$.
-----Output-----
For each test case, print the desired path time in seconds.
-----Example-----
Input
5
NNN
NS
WWEN
WWEE
NWNWS
Output
15
6
16
12
25
"""
|
def JfYEb():
DIR = {"N": (0, 1), "S": (0, -1), "W": (-1, 0), "E": (1, 0)}
for t in range(int(input())):
path = input()
tracks = set()
x, y = 0, 0
time = 0
for char in path:
x1 = x + DIR[char][0]
y1 = y + DIR[char][1]
if (x, y, x1, y1) in tracks or (x1, y1, x, y) in tracks:
time += 1
else:
time += 5
tracks.add((x, y, x1, y1))
x, y = x1, y1
print(time)
| 5
NNN
NS
WWEN
WWEE
NWNWS
| interview |
def JLEqt():
"""Lately, Mr. Chanek frequently plays the game Arena of Greed. As the name implies, the game's goal is to find the greediest of them all, who will then be crowned king of Compfestnesia.
The game is played by two people taking turns, where Mr. Chanek takes the first turn. Initially, there is a treasure chest containing $N$ gold coins. The game ends if there are no more gold coins in the chest. In each turn, the players can make one of the following moves: Take one gold coin from the chest. Take half of the gold coins on the chest. This move is only available if the number of coins in the chest is even.
Both players will try to maximize the number of coins they have. Mr. Chanek asks your help to find the maximum number of coins he can get at the end of the game if both he and the opponent plays optimally.
-----Input-----
The first line contains a single integer $T$ $(1 \le T \le 10^5)$ denotes the number of test cases.
The next $T$ lines each contain a single integer $N$ $(1 \le N \le 10^{18})$.
-----Output-----
$T$ lines, each line is the answer requested by Mr. Chanek.
-----Example-----
Input
2
5
6
Output
2
4
-----Note-----
For the first case, the game is as follows: Mr. Chanek takes one coin. The opponent takes two coins. Mr. Chanek takes one coin. The opponent takes one coin.
For the second case, the game is as follows: Mr. Chanek takes three coins. The opponent takes one coin. Mr. Chanek takes one coin. The opponent takes one coin.
"""
| from sys import stdin, stdout
from collections import defaultdict
def JLEqt():
input = stdin.readline
for _ in range(int(input())):
n = int(input())
chanek = 0
flag = 1
while n>0:
if n%4==0 and n!=4:
if flag:
chanek += 1
n-=1
flag = 0
else:
n-=1
flag = 1
elif n%2:
if flag:
chanek += 1
n-=1
flag = 0
else:
n-=1
flag = 1
else:
if flag:
chanek += n//2
n//=2
flag = 0
else:
n//=2
flag = 1
print(chanek) | 2
5
6
| interview |
def rIsBu():
"""You have a large electronic screen which can display up to $998244353$ decimal digits. The digits are displayed in the same way as on different electronic alarm clocks: each place for a digit consists of $7$ segments which can be turned on and off to compose different digits. The following picture describes how you can display all $10$ decimal digits:
[Image]
As you can see, different digits may require different number of segments to be turned on. For example, if you want to display $1$, you have to turn on $2$ segments of the screen, and if you want to display $8$, all $7$ segments of some place to display a digit should be turned on.
You want to display a really large integer on the screen. Unfortunately, the screen is bugged: no more than $n$ segments can be turned on simultaneously. So now you wonder what is the greatest integer that can be displayed by turning on no more than $n$ segments.
Your program should be able to process $t$ different test cases.
-----Input-----
The first line contains one integer $t$ ($1 \le t \le 100$) β the number of test cases in the input.
Then the test cases follow, each of them is represented by a separate line containing one integer $n$ ($2 \le n \le 10^5$) β the maximum number of segments that can be turned on in the corresponding testcase.
It is guaranteed that the sum of $n$ over all test cases in the input does not exceed $10^5$.
-----Output-----
For each test case, print the greatest integer that can be displayed by turning on no more than $n$ segments of the screen. Note that the answer may not fit in the standard $32$-bit or $64$-bit integral data type.
-----Example-----
Input
2
3
4
Output
7
11
"""
|
def rIsBu():
for _ in range(int(input())):
n = int(input())
if(n%2):
print("7"+"1"*((n-3)//2))
else:
print("1"*(n//2)) | 2
3
4
| interview |
def qoGCc():
"""Young wilderness explorers set off to their first expedition led by senior explorer Russell. Explorers went into a forest, set up a camp and decided to split into groups to explore as much interesting locations as possible. Russell was trying to form groups, but ran into some difficulties...
Most of the young explorers are inexperienced, and sending them alone would be a mistake. Even Russell himself became senior explorer not long ago. Each of young explorers has a positive integer parameter $e_i$Β β his inexperience. Russell decided that an explorer with inexperience $e$ can only join the group of $e$ or more people.
Now Russell needs to figure out how many groups he can organize. It's not necessary to include every explorer in one of the groups: some can stay in the camp. Russell is worried about this expedition, so he asked you to help him.
-----Input-----
The first line contains the number of independent test cases $T$($1 \leq T \leq 2 \cdot 10^5$). Next $2T$ lines contain description of test cases.
The first line of description of each test case contains the number of young explorers $N$ ($1 \leq N \leq 2 \cdot 10^5$).
The second line contains $N$ integers $e_1, e_2, \ldots, e_N$ ($1 \leq e_i \leq N$), where $e_i$ is the inexperience of the $i$-th explorer.
It's guaranteed that sum of all $N$ doesn't exceed $3 \cdot 10^5$.
-----Output-----
Print $T$ numbers, each number on a separate line.
In $i$-th line print the maximum number of groups Russell can form in $i$-th test case.
-----Example-----
Input
2
3
1 1 1
5
2 3 1 2 2
Output
3
2
-----Note-----
In the first example we can organize three groups. There will be only one explorer in each group. It's correct because inexperience of each explorer equals to $1$, so it's not less than the size of his group.
In the second example we can organize two groups. Explorers with inexperience $1$, $2$ and $3$ will form the first group, and the other two explorers with inexperience equal to $2$ will form the second group.
This solution is not unique. For example, we can form the first group using the three explorers with inexperience equal to $2$, and the second group using only one explorer with inexperience equal to $1$. In this case the young explorer with inexperience equal to $3$ will not be included in any group.
"""
| import sys
def qoGCc():
input=sys.stdin.readline
for _ in range(int(input())):
N=int(input())
e=list(map(int,input().split()))
e.sort()
ans=0
val=0
g=0
for i in range(0,N):
g+=1
val=e[i]
if g>=val:
ans+=1
g=0
val=0
print(ans) | 2
3
1 1 1
5
2 3 1 2 2
| interview |
def xHwiQ():
"""It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch.
Marmot brought Mole n ordered piles of worms such that i-th pile contains a_{i} worms. He labeled all these worms with consecutive integers: worms in first pile are labeled with numbers 1 to a_1, worms in second pile are labeled with numbers a_1 + 1 to a_1 + a_2 and so on. See the example for a better understanding.
Mole can't eat all the worms (Marmot brought a lot) and, as we all know, Mole is blind, so Marmot tells him the labels of the best juicy worms. Marmot will only give Mole a worm if Mole says correctly in which pile this worm is contained.
Poor Mole asks for your help. For all juicy worms said by Marmot, tell Mole the correct answers.
-----Input-----
The first line contains a single integer n (1 β€ n β€ 10^5), the number of piles.
The second line contains n integers a_1, a_2, ..., a_{n} (1 β€ a_{i} β€ 10^3, a_1 + a_2 + ... + a_{n} β€ 10^6), where a_{i} is the number of worms in the i-th pile.
The third line contains single integer m (1 β€ m β€ 10^5), the number of juicy worms said by Marmot.
The fourth line contains m integers q_1, q_2, ..., q_{m} (1 β€ q_{i} β€ a_1 + a_2 + ... + a_{n}), the labels of the juicy worms.
-----Output-----
Print m lines to the standard output. The i-th line should contain an integer, representing the number of the pile where the worm labeled with the number q_{i} is.
-----Examples-----
Input
5
2 7 3 4 9
3
1 25 11
Output
1
5
3
-----Note-----
For the sample input:
The worms with labels from [1, 2] are in the first pile. The worms with labels from [3, 9] are in the second pile. The worms with labels from [10, 12] are in the third pile. The worms with labels from [13, 16] are in the fourth pile. The worms with labels from [17, 25] are in the fifth pile.
"""
|
def xHwiQ():
n=int(input())
a=list(map(int,input().split()))
k=[]
for i in range(n):
for j in range(a[i]):
k.append(i+1)
m=int(input())
b=list(map(int,input().split()))
for i in b:
print(k[i-1]) | 5
2 7 3 4 9
3
1 25 11
| interview |
def yKUiz():
"""Yeah, we failed to make up a New Year legend for this problem.
A permutation of length $n$ is an array of $n$ integers such that every integer from $1$ to $n$ appears in it exactly once.
An element $y$ of permutation $p$ is reachable from element $x$ if $x = y$, or $p_x = y$, or $p_{p_x} = y$, and so on.
The decomposition of a permutation $p$ is defined as follows: firstly, we have a permutation $p$, all elements of which are not marked, and an empty list $l$. Then we do the following: while there is at least one not marked element in $p$, we find the leftmost such element, list all elements that are reachable from it in the order they appear in $p$, mark all of these elements, then cyclically shift the list of those elements so that the maximum appears at the first position, and add this list as an element of $l$. After all elements are marked, $l$ is the result of this decomposition.
For example, if we want to build a decomposition of $p = [5, 4, 2, 3, 1, 7, 8, 6]$, we do the following: initially $p = [5, 4, 2, 3, 1, 7, 8, 6]$ (bold elements are marked), $l = []$; the leftmost unmarked element is $5$; $5$ and $1$ are reachable from it, so the list we want to shift is $[5, 1]$; there is no need to shift it, since maximum is already the first element; $p = [\textbf{5}, 4, 2, 3, \textbf{1}, 7, 8, 6]$, $l = [[5, 1]]$; the leftmost unmarked element is $4$, the list of reachable elements is $[4, 2, 3]$; the maximum is already the first element, so there's no need to shift it; $p = [\textbf{5}, \textbf{4}, \textbf{2}, \textbf{3}, \textbf{1}, 7, 8, 6]$, $l = [[5, 1], [4, 2, 3]]$; the leftmost unmarked element is $7$, the list of reachable elements is $[7, 8, 6]$; we have to shift it, so it becomes $[8, 6, 7]$; $p = [\textbf{5}, \textbf{4}, \textbf{2}, \textbf{3}, \textbf{1}, \textbf{7}, \textbf{8}, \textbf{6}]$, $l = [[5, 1], [4, 2, 3], [8, 6, 7]]$; all elements are marked, so $[[5, 1], [4, 2, 3], [8, 6, 7]]$ is the result.
The New Year transformation of a permutation is defined as follows: we build the decomposition of this permutation; then we sort all lists in decomposition in ascending order of the first elements (we don't swap the elements in these lists, only the lists themselves); then we concatenate the lists into one list which becomes a new permutation. For example, the New Year transformation of $p = [5, 4, 2, 3, 1, 7, 8, 6]$ is built as follows: the decomposition is $[[5, 1], [4, 2, 3], [8, 6, 7]]$; after sorting the decomposition, it becomes $[[4, 2, 3], [5, 1], [8, 6, 7]]$; $[4, 2, 3, 5, 1, 8, 6, 7]$ is the result of the transformation.
We call a permutation good if the result of its transformation is the same as the permutation itself. For example, $[4, 3, 1, 2, 8, 5, 6, 7]$ is a good permutation; and $[5, 4, 2, 3, 1, 7, 8, 6]$ is bad, since the result of transformation is $[4, 2, 3, 5, 1, 8, 6, 7]$.
Your task is the following: given $n$ and $k$, find the $k$-th (lexicographically) good permutation of length $n$.
-----Input-----
The first line contains one integer $t$ ($1 \le t \le 1000$) β the number of test cases.
Then the test cases follow. Each test case is represented by one line containing two integers $n$ and $k$ ($1 \le n \le 50$, $1 \le k \le 10^{18}$).
-----Output-----
For each test case, print the answer to it as follows: if the number of good permutations of length $n$ is less than $k$, print one integer $-1$; otherwise, print the $k$-th good permutation on $n$ elements (in lexicographical order).
-----Example-----
Input
5
3 3
5 15
4 13
6 8
4 2
Output
2 1 3
3 1 2 5 4
-1
1 2 6 3 4 5
1 2 4 3
"""
| from math import factorial as fact
def yKUiz():
3
N = 55
c = [1]
for i in range(N):
c.append(fact(i))
dp = [0] * N
dp[0] = 1
for i in range(1, N):
for j in range(i):
dp[i] += dp[j] * c[i - j - 1]
def get_kth_cycle(n, k):
if n == 1:
return [1]
ans = [-1] * n
ans[0] = n - 1
fin = [i for i in range(n)]
fin[0] = n - 1
init = [i for i in range(n)]
init[n - 1] = 0
used = [False] * n
used[n - 1] = True
for i in range(1, n - 1):
j = 0
cur = fact(n - i - 2)
while True:
while used[j] or (i < n - 1 and j == init[i]):
j += 1
if k > cur:
k -= cur
j += 1
else:
fin[init[i]] = fin[j]
init[fin[j]] = init[i]
ans[i] = j
used[j] = True
break
ans[-1] = init[-1]
return [x + 1 for x in ans]
def f(n, k):
if n == 0:
assert k == 1
return []
cl = 1
while c[cl - 1] * dp[n - cl] < k:
k -= c[cl - 1] * dp[n - cl]
cl += 1
rest = f(n - cl, (k - 1) % dp[n - cl] + 1)
rest = [x + cl for x in rest]
k = (k - 1) // dp[n - cl] + 1
return get_kth_cycle(cl, k) + rest
def solve():
n, k = list(map(int, input().split()))
if k > dp[n]:
print(-1)
return
print(*f(n, k))
def main():
t = int(input())
while t > 0:
t -= 1
solve()
main() | 5
3 3
5 15
4 13
6 8
4 2
| interview |
def TIFuk():
"""Two players decided to play one interesting card game.
There is a deck of $n$ cards, with values from $1$ to $n$. The values of cards are pairwise different (this means that no two different cards have equal values). At the beginning of the game, the deck is completely distributed between players such that each player has at least one card.
The game goes as follows: on each turn, each player chooses one of their cards (whichever they want) and puts on the table, so that the other player doesn't see which card they chose. After that, both cards are revealed, and the player, value of whose card was larger, takes both cards in his hand. Note that as all cards have different values, one of the cards will be strictly larger than the other one. Every card may be played any amount of times. The player loses if he doesn't have any cards.
For example, suppose that $n = 5$, the first player has cards with values $2$ and $3$, and the second player has cards with values $1$, $4$, $5$. Then one possible flow of the game is:
The first player chooses the card $3$. The second player chooses the card $1$. As $3>1$, the first player gets both cards. Now the first player has cards $1$, $2$, $3$, the second player has cards $4$, $5$.
The first player chooses the card $3$. The second player chooses the card $4$. As $3<4$, the second player gets both cards. Now the first player has cards $1$, $2$. The second player has cards $3$, $4$, $5$.
The first player chooses the card $1$. The second player chooses the card $3$. As $1<3$, the second player gets both cards. Now the first player has only the card $2$. The second player has cards $1$, $3$, $4$, $5$.
The first player chooses the card $2$. The second player chooses the card $4$. As $2<4$, the second player gets both cards. Now the first player is out of cards and loses. Therefore, the second player wins.
Who will win if both players are playing optimally? It can be shown that one of the players has a winning strategy.
-----Input-----
Each test contains multiple test cases. The first line contains the number of test cases $t$ ($1 \le t \le 100$). The description of the test cases follows.
The first line of each test case contains three integers $n$, $k_1$, $k_2$ ($2 \le n \le 100, 1 \le k_1 \le n - 1, 1 \le k_2 \le n - 1, k_1 + k_2 = n$)Β β the number of cards, number of cards owned by the first player and second player correspondingly.
The second line of each test case contains $k_1$ integers $a_1, \dots, a_{k_1}$ ($1 \le a_i \le n$)Β β the values of cards of the first player.
The third line of each test case contains $k_2$ integers $b_1, \dots, b_{k_2}$ ($1 \le b_i \le n$)Β β the values of cards of the second player.
It is guaranteed that the values of all cards are different.
-----Output-----
For each test case, output "YES" in a separate line, if the first player wins. Otherwise, output "NO" in a separate line. You can print each letter in any case (upper or lower).
-----Example-----
Input
2
2 1 1
2
1
5 2 3
2 3
1 4 5
Output
YES
NO
-----Note-----
In the first test case of the example, there is only one possible move for every player: the first player will put $2$, the second player will put $1$. $2>1$, so the first player will get both cards and will win.
In the second test case of the example, it can be shown that it is the second player who has a winning strategy. One possible flow of the game is illustrated in the statement.
"""
|
def TIFuk():
q = int(input())
for z in range(q):
n, k1, k2 = map(int, input().split())
arr1 = list(map(int, input().split()))
arr2 = list(map(int, input().split()))
if max(arr1) > max(arr2):
print('YES')
else:
print('NO') | 2
2 1 1
2
1
5 2 3
2 3
1 4 5
| interview |
def EkLFt():
"""After a long party Petya decided to return home, but he turned out to be at the opposite end of the town from his home. There are $n$ crossroads in the line in the town, and there is either the bus or the tram station at each crossroad.
The crossroads are represented as a string $s$ of length $n$, where $s_i = \texttt{A}$, if there is a bus station at $i$-th crossroad, and $s_i = \texttt{B}$, if there is a tram station at $i$-th crossroad. Currently Petya is at the first crossroad (which corresponds to $s_1$) and his goal is to get to the last crossroad (which corresponds to $s_n$).
If for two crossroads $i$ and $j$ for all crossroads $i, i+1, \ldots, j-1$ there is a bus station, one can pay $a$ roubles for the bus ticket, and go from $i$-th crossroad to the $j$-th crossroad by the bus (it is not necessary to have a bus station at the $j$-th crossroad). Formally, paying $a$ roubles Petya can go from $i$ to $j$ if $s_t = \texttt{A}$ for all $i \le t < j$.
If for two crossroads $i$ and $j$ for all crossroads $i, i+1, \ldots, j-1$ there is a tram station, one can pay $b$ roubles for the tram ticket, and go from $i$-th crossroad to the $j$-th crossroad by the tram (it is not necessary to have a tram station at the $j$-th crossroad). Formally, paying $b$ roubles Petya can go from $i$ to $j$ if $s_t = \texttt{B}$ for all $i \le t < j$.
For example, if $s$="AABBBAB", $a=4$ and $b=3$ then Petya needs:[Image] buy one bus ticket to get from $1$ to $3$, buy one tram ticket to get from $3$ to $6$, buy one bus ticket to get from $6$ to $7$.
Thus, in total he needs to spend $4+3+4=11$ roubles. Please note that the type of the stop at the last crossroad (i.e. the character $s_n$) does not affect the final expense.
Now Petya is at the first crossroad, and he wants to get to the $n$-th crossroad. After the party he has left with $p$ roubles. He's decided to go to some station on foot, and then go to home using only public transport.
Help him to choose the closest crossroad $i$ to go on foot the first, so he has enough money to get from the $i$-th crossroad to the $n$-th, using only tram and bus tickets.
-----Input-----
Each test contains one or more test cases. The first line contains the number of test cases $t$ ($1 \le t \le 10^4$).
The first line of each test case consists of three integers $a, b, p$ ($1 \le a, b, p \le 10^5$)Β β the cost of bus ticket, the cost of tram ticket and the amount of money Petya has.
The second line of each test case consists of one string $s$, where $s_i = \texttt{A}$, if there is a bus station at $i$-th crossroad, and $s_i = \texttt{B}$, if there is a tram station at $i$-th crossroad ($2 \le |s| \le 10^5$).
It is guaranteed, that the sum of the length of strings $s$ by all test cases in one test doesn't exceed $10^5$.
-----Output-----
For each test case print one numberΒ β the minimal index $i$ of a crossroad Petya should go on foot. The rest of the path (i.e. from $i$ to $n$ he should use public transport).
-----Example-----
Input
5
2 2 1
BB
1 1 1
AB
3 2 8
AABBBBAABB
5 3 4
BBBBB
2 1 1
ABABAB
Output
2
1
3
1
6
"""
|
def EkLFt():
t=int(input())
for tt in range(t):
a,b,p=map(int,input().split())
s=input()
n=len(s)
cost = [0]*n
cost[-1] = 0
typ = ''
i=n-2
while i>=0:
if s[i]==typ:
cost[i] = cost[i+1]
else:
typ = s[i]
cost[i] = cost[i+1] + (a if typ=='A' else b)
i-=1
i=0
while cost[i] > p:
i+=1
print(i+1) | 5
2 2 1
BB
1 1 1
AB
3 2 8
AABBBBAABB
5 3 4
BBBBB
2 1 1
ABABAB
| interview |
def yjAnQ():
"""You are given a sequence $a_1, a_2, \dots, a_n$, consisting of integers.
You can apply the following operation to this sequence: choose some integer $x$ and move all elements equal to $x$ either to the beginning, or to the end of $a$. Note that you have to move all these elements in one direction in one operation.
For example, if $a = [2, 1, 3, 1, 1, 3, 2]$, you can get the following sequences in one operation (for convenience, denote elements equal to $x$ as $x$-elements): $[1, 1, 1, 2, 3, 3, 2]$ if you move all $1$-elements to the beginning; $[2, 3, 3, 2, 1, 1, 1]$ if you move all $1$-elements to the end; $[2, 2, 1, 3, 1, 1, 3]$ if you move all $2$-elements to the beginning; $[1, 3, 1, 1, 3, 2, 2]$ if you move all $2$-elements to the end; $[3, 3, 2, 1, 1, 1, 2]$ if you move all $3$-elements to the beginning; $[2, 1, 1, 1, 2, 3, 3]$ if you move all $3$-elements to the end;
You have to determine the minimum number of such operations so that the sequence $a$ becomes sorted in non-descending order. Non-descending order means that for all $i$ from $2$ to $n$, the condition $a_{i-1} \le a_i$ is satisfied.
Note that you have to answer $q$ independent queries.
-----Input-----
The first line contains one integer $q$ ($1 \le q \le 3 \cdot 10^5$)Β β the number of the queries. Each query is represented by two consecutive lines.
The first line of each query contains one integer $n$ ($1 \le n \le 3 \cdot 10^5$)Β β the number of elements.
The second line of each query contains $n$ integers $a_1, a_2, \dots , a_n$ ($1 \le a_i \le n$)Β β the elements.
It is guaranteed that the sum of all $n$ does not exceed $3 \cdot 10^5$.
-----Output-----
For each query print one integerΒ β the minimum number of operation for sorting sequence $a$ in non-descending order.
-----Example-----
Input
3
7
3 1 6 6 3 1 1
8
1 1 4 4 4 7 8 8
7
4 2 5 2 6 2 7
Output
2
0
1
-----Note-----
In the first query, you can move all $1$-elements to the beginning (after that sequence turn into $[1, 1, 1, 3, 6, 6, 3]$) and then move all $6$-elements to the end.
In the second query, the sequence is sorted initially, so the answer is zero.
In the third query, you have to move all $2$-elements to the beginning.
"""
|
def yjAnQ():
def main():
from sys import stdin, stdout
for _ in range(int(stdin.readline())):
n = int(stdin.readline())
inp1 = [-1] * (n + 1)
inp2 = [-1] * (n + 1)
for i, ai in enumerate(map(int, stdin.readline().split())):
if inp1[ai] < 0:
inp1[ai] = i
inp2[ai] = i
inp1 = tuple((inp1i for inp1i in inp1 if inp1i >= 0))
inp2 = tuple((inp2i for inp2i in inp2 if inp2i >= 0))
n = len(inp1)
ans = 0
cur = 0
for i in range(n):
if i and inp1[i] < inp2[i - 1]:
cur = 1
else:
cur += 1
ans = max(ans, cur)
stdout.write(f'{n - ans}\n')
main()
| 3
7
3 1 6 6 3 1 1
8
1 1 4 4 4 7 8 8
7
4 2 5 2 6 2 7
| interview |
def XnBWT():
"""You are fed up with your messy room, so you decided to clean it up.
Your room is a bracket sequence $s=s_{1}s_{2}\dots s_{n}$ of length $n$. Each character of this string is either an opening bracket '(' or a closing bracket ')'.
In one operation you can choose any consecutive substring of $s$ and reverse it. In other words, you can choose any substring $s[l \dots r]=s_l, s_{l+1}, \dots, s_r$ and change the order of elements in it into $s_r, s_{r-1}, \dots, s_{l}$.
For example, if you will decide to reverse substring $s[2 \dots 4]$ of string $s=$"((()))" it will be equal to $s=$"()(())".
A regular (aka balanced) bracket sequence is a bracket sequence that can be transformed into a correct arithmetic expression by inserting characters '1' and '+' between the original characters of the sequence. For example, bracket sequences "()()", "(())" are regular (the resulting expressions are: "(1)+(1)", "((1+1)+1)"), and ")(" and "(" are not.
A prefix of a string $s$ is a substring that starts at position $1$. For example, for $s=$"(())()" there are $6$ prefixes: "(", "((", "(()", "(())", "(())(" and "(())()".
In your opinion, a neat and clean room $s$ is a bracket sequence that:
the whole string $s$ is a regular bracket sequence; and there are exactly $k$ prefixes of this sequence which are regular (including whole $s$ itself).
For example, if $k = 2$, then "(())()" is a neat and clean room.
You want to use at most $n$ operations to make your room neat and clean. Operations are applied one after another sequentially.
It is guaranteed that the answer exists. Note that you do not need to minimize the number of operations: find any way to achieve the desired configuration in $n$ or less operations.
-----Input-----
The first line contains integer number $t$ ($1 \le t \le 100$)Β β the number of test cases in the input. Then $t$ test cases follow.
The first line of a test case contains two integers $n$ and $k$ ($1 \le k \le \frac{n}{2}, 2 \le n \le 2000$, $n$ is even)Β β length of $s$ and required number of regular prefixes.
The second line of a test case contains $s$ of length $n$Β β the given bracket sequence. It contains only '(' and ')'.
It is guaranteed that there are exactly $\frac{n}{2}$ characters '(' and exactly $\frac{n}{2}$ characters ')' in the given string.
The sum of all values $n$ over all the test cases in the input doesn't exceed $2000$.
-----Output-----
For each test case print an answer.
In the first line print integer $m$ ($0 \le m \le n$)Β β the number of operations. You do not need to minimize $m$, any value is suitable.
In the following $m$ lines print description of the operations, each line should contain two integers $l,r$ ($1 \le l \le r \le n$), representing single reverse operation of $s[l \dots r]=s_{l}s_{l+1}\dots s_{r}$. Operations are applied one after another sequentially.
The final $s$ after all operations should be a regular, also it should be exactly $k$ prefixes (including $s$) which are regular.
It is guaranteed that the answer exists. If there are several possible answers you can print any.
-----Example-----
Input
4
8 2
()(())()
10 3
))()()()((
2 1
()
2 1
)(
Output
4
3 4
1 1
5 8
2 2
3
4 10
1 4
6 7
0
1
1 2
-----Note-----
In the first example, the final sequence is "()(()())", where two prefixes are regular, "()" and "()(()())". Note, that all the operations except "5 8" in the example output are useless (they do not change $s$).
"""
|
def XnBWT():
t = int(input())
for tt in range(t):
n,k=list(map(int,input().split()))
s = input()
ans = []
if s[0] == ')':
for i in range(n):
if s[i] == '(':
ans.append([1,i+1])
s = s[i::-1] + s[i+1:]
break
for i in range(1,(k-1)*2):
if i%2==0:
if s[i]!='(':
for j in range(i+1,n):
if s[j] == '(':
ans.append([i+1,j+1])
s = s[:i] + s[j:i-1:-1] + s[j+1:]
break
else:
if s[i]!=')':
for j in range(i+1,n):
if s[j] == ')':
ans.append([i+1,j+1])
s = s[:i] + s[j:i-1:-1] + s[j+1:]
break
for i in range((k-1)*2,(n+(2*(k-1)))//2+1):
if s[i]!='(':
for j in range(i+1,n):
if s[j] == '(':
ans.append([i+1,j+1])
s = s[:i] + s[j:i-1:-1] + s[j+1:]
break
print(len(ans))
for i in ans:
print(*i)
| 4
8 2
()(())()
10 3
))()()()((
2 1
()
2 1
)(
| interview |
def pELQd():
"""You are given a binary string $s$ (recall that a string is binary if each character is either $0$ or $1$).
Let $f(t)$ be the decimal representation of integer $t$ written in binary form (possibly with leading zeroes). For example $f(011) = 3, f(00101) = 5, f(00001) = 1, f(10) = 2, f(000) = 0$ and $f(000100) = 4$.
The substring $s_{l}, s_{l+1}, \dots , s_{r}$ is good if $r - l + 1 = f(s_l \dots s_r)$.
For example string $s = 1011$ has $5$ good substrings: $s_1 \dots s_1 = 1$, $s_3 \dots s_3 = 1$, $s_4 \dots s_4 = 1$, $s_1 \dots s_2 = 10$ and $s_2 \dots s_4 = 011$.
Your task is to calculate the number of good substrings of string $s$.
You have to answer $t$ independent queries.
-----Input-----
The first line contains one integer $t$ ($1 \le t \le 1000$) β the number of queries.
The only line of each query contains string $s$ ($1 \le |s| \le 2 \cdot 10^5$), consisting of only digits $0$ and $1$.
It is guaranteed that $\sum\limits_{i=1}^{t} |s_i| \le 2 \cdot 10^5$.
-----Output-----
For each query print one integer β the number of good substrings of string $s$.
-----Example-----
Input
4
0110
0101
00001000
0001000
Output
4
3
4
3
"""
|
def pELQd():
LOG = 20
def solve(s):
n = len(s)
res = 0
z = 0
for t in range(0, n):
if s[t] == '0':
z += 1
continue
for l in range(1, min(LOG, n - t + 1)):
x = int(s[t:t+l], 2)
# print(l, t, x, l + z)
if l + z >= x:
res += 1
# print(t, l, x, res, z)
z = 0
return res
t = int(input())
while t > 0:
t -= 1
s = input()
print(solve(s)) | 4
0110
0101
00001000
0001000
| interview |
def ZVwup():
"""Petya is preparing for his birthday. He decided that there would be $n$ different dishes on the dinner table, numbered from $1$ to $n$. Since Petya doesn't like to cook, he wants to order these dishes in restaurants.
Unfortunately, all dishes are prepared in different restaurants and therefore Petya needs to pick up his orders from $n$ different places. To speed up this process, he wants to order courier delivery at some restaurants. Thus, for each dish, there are two options for Petya how he can get it: the dish will be delivered by a courier from the restaurant $i$, in this case the courier will arrive in $a_i$ minutes, Petya goes to the restaurant $i$ on his own and picks up the dish, he will spend $b_i$ minutes on this.
Each restaurant has its own couriers and they start delivering the order at the moment Petya leaves the house. In other words, all couriers work in parallel. Petya must visit all restaurants in which he has not chosen delivery, he does this consistently.
For example, if Petya wants to order $n = 4$ dishes and $a = [3, 7, 4, 5]$, and $b = [2, 1, 2, 4]$, then he can order delivery from the first and the fourth restaurant, and go to the second and third on your own. Then the courier of the first restaurant will bring the order in $3$ minutes, the courier of the fourth restaurant will bring the order in $5$ minutes, and Petya will pick up the remaining dishes in $1 + 2 = 3$ minutes. Thus, in $5$ minutes all the dishes will be at Petya's house.
Find the minimum time after which all the dishes can be at Petya's home.
-----Input-----
The first line contains one positive integer $t$ ($1 \le t \le 2 \cdot 10^5$)Β β the number of test cases. Then $t$ test cases follow.
Each test case begins with a line containing one integer $n$ ($1 \le n \le 2 \cdot 10^5$)Β β the number of dishes that Petya wants to order.
The second line of each test case contains $n$ integers $a_1 \ldots a_n$ ($1 \le a_i \le 10^9$)Β β the time of courier delivery of the dish with the number $i$.
The third line of each test case contains $n$ integers $b_1 \ldots b_n$ ($1 \le b_i \le 10^9$)Β β the time during which Petya will pick up the dish with the number $i$.
The sum of $n$ over all test cases does not exceed $2 \cdot 10^5$.
-----Output-----
For each test case output one integerΒ β the minimum time after which all dishes can be at Petya's home.
-----Example-----
Input
4
4
3 7 4 5
2 1 2 4
4
1 2 3 4
3 3 3 3
2
1 2
10 10
2
10 10
1 2
Output
5
3
2
3
"""
|
def ZVwup():
def check(M):
sm = 0
for i in range(n):
if a[i] > M:
sm += b[i]
return sm <= M
gans = []
for _ in range(int(input())):
n = int(input())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
L = 0
R = max(a)
while R - L > 1:
M = (L + R) // 2
if check(M):
R = M
else:
L = M
gans.append(R)
print(*gans, sep='\n')
| 4
4
3 7 4 5
2 1 2 4
4
1 2 3 4
3 3 3 3
2
1 2
10 10
2
10 10
1 2
| interview |
def WzVDO():
"""Today the kindergarten has a new group of $n$ kids who need to be seated at the dinner table. The chairs at the table are numbered from $1$ to $4n$. Two kids can't sit on the same chair. It is known that two kids who sit on chairs with numbers $a$ and $b$ ($a \neq b$) will indulge if: $gcd(a, b) = 1$ or, $a$ divides $b$ or $b$ divides $a$.
$gcd(a, b)$Β β the maximum number $x$ such that $a$ is divisible by $x$ and $b$ is divisible by $x$.
For example, if $n=3$ and the kids sit on chairs with numbers $2$, $3$, $4$, then they will indulge since $4$ is divided by $2$ and $gcd(2, 3) = 1$. If kids sit on chairs with numbers $4$, $6$, $10$, then they will not indulge.
The teacher really doesn't want the mess at the table, so she wants to seat the kids so there are no $2$ of the kid that can indulge. More formally, she wants no pair of chairs $a$ and $b$ that the kids occupy to fulfill the condition above.
Since the teacher is very busy with the entertainment of the kids, she asked you to solve this problem.
-----Input-----
The first line contains one integer $t$ ($1 \leq t \leq 100$)Β β the number of test cases. Then $t$ test cases follow.
Each test case consists of one line containing an integer $n$ ($1 \leq n \leq 100$)Β β the number of kids.
-----Output-----
Output $t$ lines, which contain $n$ distinct integers from $1$ to $4n$Β β the numbers of chairs that the kids should occupy in the corresponding test case. If there are multiple answers, print any of them. You can print $n$ numbers in any order.
-----Example-----
Input
3
2
3
4
Output
6 4
4 6 10
14 10 12 8
"""
|
def WzVDO():
t=int(input())
for you in range(t):
n=int(input())
for i in range(n):
print(4*n-2*i,end=" ")
print()
| 3
2
3
4
| interview |
def hkfac():
"""Recently, you found a bot to play "Rock paper scissors" with. Unfortunately, the bot uses quite a simple algorithm to play: he has a string $s = s_1 s_2 \dots s_{n}$ of length $n$ where each letter is either R, S or P.
While initializing, the bot is choosing a starting index $pos$ ($1 \le pos \le n$), and then it can play any number of rounds. In the first round, he chooses "Rock", "Scissors" or "Paper" based on the value of $s_{pos}$: if $s_{pos}$ is equal to R the bot chooses "Rock"; if $s_{pos}$ is equal to S the bot chooses "Scissors"; if $s_{pos}$ is equal to P the bot chooses "Paper";
In the second round, the bot's choice is based on the value of $s_{pos + 1}$. In the third roundΒ β on $s_{pos + 2}$ and so on. After $s_n$ the bot returns to $s_1$ and continues his game.
You plan to play $n$ rounds and you've already figured out the string $s$ but still don't know what is the starting index $pos$. But since the bot's tactic is so boring, you've decided to find $n$ choices to each round to maximize the average number of wins.
In other words, let's suggest your choices are $c_1 c_2 \dots c_n$ and if the bot starts from index $pos$ then you'll win in $win(pos)$ rounds. Find $c_1 c_2 \dots c_n$ such that $\frac{win(1) + win(2) + \dots + win(n)}{n}$ is maximum possible.
-----Input-----
The first line contains a single integer $t$ ($1 \le t \le 1000$)Β β the number of test cases.
Next $t$ lines contain test casesΒ β one per line. The first and only line of each test case contains string $s = s_1 s_2 \dots s_{n}$ ($1 \le n \le 2 \cdot 10^5$; $s_i \in \{\text{R}, \text{S}, \text{P}\}$)Β β the string of the bot.
It's guaranteed that the total length of all strings in one test doesn't exceed $2 \cdot 10^5$.
-----Output-----
For each test case, print $n$ choices $c_1 c_2 \dots c_n$ to maximize the average number of wins. Print them in the same manner as the string $s$.
If there are multiple optimal answers, print any of them.
-----Example-----
Input
3
RRRR
RSP
S
Output
PPPP
RSP
R
-----Note-----
In the first test case, the bot (wherever it starts) will always choose "Rock", so we can always choose "Paper". So, in any case, we will win all $n = 4$ rounds, so the average is also equal to $4$.
In the second test case: if bot will start from $pos = 1$, then $(s_1, c_1)$ is draw, $(s_2, c_2)$ is draw and $(s_3, c_3)$ is draw, so $win(1) = 0$; if bot will start from $pos = 2$, then $(s_2, c_1)$ is win, $(s_3, c_2)$ is win and $(s_1, c_3)$ is win, so $win(2) = 3$; if bot will start from $pos = 3$, then $(s_3, c_1)$ is lose, $(s_1, c_2)$ is lose and $(s_2, c_3)$ is lose, so $win(3) = 0$; The average is equal to $\frac{0 + 3 + 0}{3} = 1$ and it can be proven that it's the maximum possible average.
A picture from Wikipedia explaining "Rock paper scissors" game: $\beta$
"""
| import sys, math, collections
def hkfac():
#
# ------------------------------------------------
# ____ _ Generatered using
# / ___| | |
# | | __ _ __| | ___ _ __ ______ _
# | | / _` |/ _` |/ _ \ '_ \|_ / _` |
# | |__| (_| | (_| | __/ | | |/ / (_| |
# \____\____|\____|\___|_| |_/___\____|
#
# GNU Affero General Public License v3.0
# ------------------------------------------------
# Author : prophet
# Created : 2020-07-12 11:19:01.523119
# UUID : aXsU7xuXyjk3Ky2f
# ------------------------------------------------
#
production = True
def input(input_format = 0, multi = 0):
if multi > 0: return [input(input_format) for i in range(multi)]
else:
next_line = sys.stdin.readline()[:-1]
if input_format >= 10:
use_list = False
input_format = int(str(input_format)[-1])
else: use_list = True
if input_format == 0: formatted_input = [next_line]
elif input_format == 1: formatted_input = list(map(int, next_line.split()))
elif input_format == 2: formatted_input = list(map(float, next_line.split()))
elif input_format == 3: formatted_input = list(next_line)
elif input_format == 4: formatted_input = list(map(int, list(next_line)))
elif input_format == 5: formatted_input = next_line.split()
else: formatted_input = [next_line]
return formatted_input if use_list else formatted_input[0]
def out(output_line, output_format = 0, newline = True):
formatted_output = ""
if output_format == 0: formatted_output = str(output_line)
elif output_format == 1: formatted_output = " ".join(map(str, output_line))
elif output_format == 2: formatted_output = "\n".join(map(str, output_line))
print(formatted_output, end = "\n" if newline else "")
def log(*args):
if not production:
print("$$$", end = "")
print(*args)
enu = enumerate
ter = lambda a, b, c: b if a else c
ceil = lambda a, b: -(-a // b)
def mapl(iterable, format = 0):
if format == 0: return list(map(int, iterable))
elif format == 1: return list(map(str, iterable))
elif format == 2: return list(map(list, iterable))
#
# >>>>>>>>>>>>>>> START OF SOLUTION <<<<<<<<<<<<<<
#
def solve():
s = input(3)
u = [0] * 3
for i in s:
if i == "R":
u[0] += 1
elif i == "P":
u[1] += 1
elif i == "S":
u[2] += 1
log(u)
y = 0
p = 0
for i, j in enu(u):
if j > y:
y = j
p = i
if p == 0:
a = "P"
elif p == 1:
a = "S"
elif p == 2:
a = "R"
out(a * len(s))
return
for i in range(input(11)): solve()
# solve()
#
# >>>>>>>>>>>>>>>> END OF SOLUTION <<<<<<<<<<<<<<<
# | 3
RRRR
RSP
S
| interview |
def HQxky():
"""This is the easy version of the problem. The difference between the versions is that the easy version has no swap operations. You can make hacks only if all versions of the problem are solved.
Pikachu is a cute and friendly pokΓ©mon living in the wild pikachu herd.
But it has become known recently that infamous team R wanted to steal all these pokΓ©mon! PokΓ©mon trainer Andrew decided to help Pikachu to build a pokΓ©mon army to resist.
First, Andrew counted all the pokΓ©monΒ β there were exactly $n$ pikachu. The strength of the $i$-th pokΓ©mon is equal to $a_i$, and all these numbers are distinct.
As an army, Andrew can choose any non-empty subsequence of pokemons. In other words, Andrew chooses some array $b$ from $k$ indices such that $1 \le b_1 < b_2 < \dots < b_k \le n$, and his army will consist of pokΓ©mons with forces $a_{b_1}, a_{b_2}, \dots, a_{b_k}$.
The strength of the army is equal to the alternating sum of elements of the subsequence; that is, $a_{b_1} - a_{b_2} + a_{b_3} - a_{b_4} + \dots$.
Andrew is experimenting with pokΓ©mon order. He performs $q$ operations. In $i$-th operation Andrew swaps $l_i$-th and $r_i$-th pokΓ©mon.
Note: $q=0$ in this version of the task.
Andrew wants to know the maximal stregth of the army he can achieve with the initial pokΓ©mon placement. He also needs to know the maximal strength after each operation.
Help Andrew and the pokΓ©mon, or team R will realize their tricky plan!
-----Input-----
Each test contains multiple test cases.
The first line contains one positive integer $t$ ($1 \le t \le 10^3$) denoting the number of test cases. Description of the test cases follows.
The first line of each test case contains two integers $n$ and $q$ ($1 \le n \le 3 \cdot 10^5, q = 0$) denoting the number of pokΓ©mon and number of operations respectively.
The second line contains $n$ distinct positive integers $a_1, a_2, \dots, a_n$ ($1 \le a_i \le n$) denoting the strengths of the pokΓ©mon.
$i$-th of the last $q$ lines contains two positive integers $l_i$ and $r_i$ ($1 \le l_i \le r_i \le n$) denoting the indices of pokΓ©mon that were swapped in the $i$-th operation.
It is guaranteed that the sum of $n$ over all test cases does not exceed $3 \cdot 10^5$, and the sum of $q$ over all test cases does not exceed $3 \cdot 10^5$.
-----Output-----
For each test case, print $q+1$ integers: the maximal strength of army before the swaps and after each swap.
-----Example-----
Input
3
3 0
1 3 2
2 0
1 2
7 0
1 2 5 4 3 6 7
Output
3
2
9
-----Note-----
In third test case we can build an army in such way: [1 2 5 4 3 6 7], its strength will be $5β3+7=9$.
"""
| import sys
from bisect import bisect_right
def HQxky():
input = sys.stdin.readline
bin_s = [1]
while bin_s[-1] <= 10 ** 9:
bin_s.append(bin_s[-1] * 2)
def main():
n, q = map(int, input().split())
alst = list(map(int, input().split()))
dp = [[-1, -1] for _ in range(n)]
dp[0] = [alst[0], 0]
for i, a in enumerate(alst[1:], start = 1):
dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] + a)
dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] - a)
print(max(dp[-1]))
for _ in range(int(input())):
main() | 3
3 0
1 3 2
2 0
1 2
7 0
1 2 5 4 3 6 7
| interview |
def ioSts():
"""You are playing a very popular game called Cubecraft. Initially, you have one stick and want to craft $k$ torches. One torch can be crafted using one stick and one coal.
Hopefully, you've met a very handsome wandering trader who has two trade offers: exchange $1$ stick for $x$ sticks (you lose $1$ stick and gain $x$ sticks). exchange $y$ sticks for $1$ coal (you lose $y$ sticks and gain $1$ coal).
During one trade, you can use only one of these two trade offers. You can use each trade offer any number of times you want to, in any order.
Your task is to find the minimum number of trades you need to craft at least $k$ torches. The answer always exists under the given constraints.
You have to answer $t$ independent test cases.
-----Input-----
The first line of the input contains one integer $t$ ($1 \le t \le 2 \cdot 10^4$) β the number of test cases. Then $t$ test cases follow.
The only line of the test case contains three integers $x$, $y$ and $k$ ($2 \le x \le 10^9$; $1 \le y, k \le 10^9$) β the number of sticks you can buy with one stick, the number of sticks required to buy one coal and the number of torches you need, respectively.
-----Output-----
For each test case, print the answer: the minimum number of trades you need to craft at least $k$ torches. The answer always exists under the given constraints.
-----Example-----
Input
5
2 1 5
42 13 24
12 11 12
1000000000 1000000000 1000000000
2 1000000000 1000000000
Output
14
33
25
2000000003
1000000001999999999
"""
|
def ioSts():
for haaghfj in range(int(input())):
x,y,k = list(map(int,input().split()))
print(k + (y * k + k - 1 +x-2) // (x - 1))
| 5
2 1 5
42 13 24
12 11 12
1000000000 1000000000 1000000000
2 1000000000 1000000000
| interview |
def EIQbX():
"""Let's call some positive integer classy if its decimal representation contains no more than $3$ non-zero digits. For example, numbers $4$, $200000$, $10203$ are classy and numbers $4231$, $102306$, $7277420000$ are not.
You are given a segment $[L; R]$. Count the number of classy integers $x$ such that $L \le x \le R$.
Each testcase contains several segments, for each of them you are required to solve the problem separately.
-----Input-----
The first line contains a single integer $T$ ($1 \le T \le 10^4$) β the number of segments in a testcase.
Each of the next $T$ lines contains two integers $L_i$ and $R_i$ ($1 \le L_i \le R_i \le 10^{18}$).
-----Output-----
Print $T$ lines β the $i$-th line should contain the number of classy integers on a segment $[L_i; R_i]$.
-----Example-----
Input
4
1 1000
1024 1024
65536 65536
999999 1000001
Output
1000
1
0
2
"""
| import sys
def EIQbX():
#sys.stdin=open("data.txt")
input=sys.stdin.readline
# this math tutorial is boring
classy=set()
for i in range(19):
for j in range(i):
for k in range(j):
for a in range(10): # a=0 for good measure
for b in range(10):
for c in range(10):
what=a*10**i+b*10**j+c*10**k
classy.add(what)
li=sorted(classy)
def counting(i):
# return len([x for x in li if x <= i])+C
lo=0
hi=len(li)-1
while lo<hi:
mid=(lo+hi+1)//2
if li[mid]<=i:
lo=mid
else:
hi=mid-1
return lo
for _ in range(int(input())):
a,b=map(int,input().split())
print(counting(b)-counting(a-1)) | 4
1 1000
1024 1024
65536 65536
999999 1000001
| interview |
def QcoeM():
"""Karlsson has recently discovered a huge stock of berry jam jars in the basement of the house. More specifically, there were $2n$ jars of strawberry and blueberry jam.
All the $2n$ jars are arranged in a row. The stairs to the basement are exactly in the middle of that row. So when Karlsson enters the basement, he sees exactly $n$ jars to his left and $n$ jars to his right.
For example, the basement might look like this: [Image]
Being the starightforward man he is, he immediately starts eating the jam. In one minute he chooses to empty either the first non-empty jar to his left or the first non-empty jar to his right.
Finally, Karlsson decided that at the end the amount of full strawberry and blueberry jam jars should become the same.
For example, this might be the result: [Image] He has eaten $1$ jar to his left and then $5$ jars to his right. There remained exactly $3$ full jars of both strawberry and blueberry jam.
Jars are numbered from $1$ to $2n$ from left to right, so Karlsson initially stands between jars $n$ and $n+1$.
What is the minimum number of jars Karlsson is required to empty so that an equal number of full strawberry and blueberry jam jars is left?
Your program should answer $t$ independent test cases.
-----Input-----
The first line contains one integer $t$ ($1 \le t \le 1000$) β the number of test cases.
The first line of each test case contains a single integer $n$ ($1 \le n \le 10^5$).
The second line of each test case contains $2n$ integers $a_1, a_2, \dots, a_{2n}$ ($1 \le a_i \le 2$) β $a_i=1$ means that the $i$-th jar from the left is a strawberry jam jar and $a_i=2$ means that it is a blueberry jam jar.
It is guaranteed that the sum of $n$ over all test cases does not exceed $10^5$.
-----Output-----
For each test case print the answer to it β the minimum number of jars Karlsson is required to empty so that an equal number of full strawberry and blueberry jam jars is left.
-----Example-----
Input
4
6
1 1 1 2 2 1 2 1 2 1 1 2
2
1 2 1 2
3
1 1 1 1 1 1
2
2 1 1 1
Output
6
0
6
2
-----Note-----
The picture from the statement describes the first test case.
In the second test case the number of strawberry and blueberry jam jars is already equal.
In the third test case Karlsson is required to eat all $6$ jars so that there remain $0$ jars of both jams.
In the fourth test case Karlsson can empty either the second and the third jars or the third and the fourth one. The both scenarios will leave $1$ jar of both jams.
"""
|
def QcoeM():
for tcase in range(int(input())):
n=int(input())
ls = list(map(int, input().split()))
oneneed = 2*(n - ls.count(1))
ldct = {0:0}
ctr = 0
eaten = 0
for i in range(n-1,-1,-1):
eaten += 1
ctr += (1 if ls[i] == 2 else -1)
if ctr not in ldct:
ldct[ctr] = eaten
rdct = {0:0}
ctr = 0
eaten = 0
for i in range(n,2*n):
eaten += 1
ctr += (1 if ls[i] == 2 else -1)
if ctr not in rdct:
rdct[ctr] = eaten
#print(oneneed, ldct, rdct)
best=99**99
for k in list(rdct.keys()):
otk = oneneed - k
if otk in ldct:
best = min(best, rdct[k]+ldct[otk])
print(best)
| 4
6
1 1 1 2 2 1 2 1 2 1 1 2
2
1 2 1 2
3
1 1 1 1 1 1
2
2 1 1 1
| interview |
def fwKUl():
"""There are n games in a football tournament. Three teams are participating in it. Currently k games had already been played.
You are an avid football fan, but recently you missed the whole k games. Fortunately, you remember a guess of your friend for these k games. Your friend did not tell exact number of wins of each team, instead he thought that absolute difference between number of wins of first and second team will be d_1 and that of between second and third team will be d_2.
You don't want any of team win the tournament, that is each team should have the same number of wins after n games. That's why you want to know: does there exist a valid tournament satisfying the friend's guess such that no team will win this tournament?
Note that outcome of a match can not be a draw, it has to be either win or loss.
-----Input-----
The first line of the input contains a single integer corresponding to number of test cases t (1 β€ t β€ 10^5).
Each of the next t lines will contain four space-separated integers n, k, d_1, d_2 (1 β€ n β€ 10^12;Β 0 β€ k β€ n;Β 0 β€ d_1, d_2 β€ k) β data for the current test case.
-----Output-----
For each test case, output a single line containing either "yes" if it is possible to have no winner of tournament, or "no" otherwise (without quotes).
-----Examples-----
Input
5
3 0 0 0
3 3 0 0
6 4 1 0
6 3 3 0
3 3 3 2
Output
yes
yes
yes
no
no
-----Note-----
Sample 1. There has not been any match up to now (k = 0, d_1 = 0, d_2 = 0). If there will be three matches (1-2, 2-3, 3-1) and each team wins once, then at the end each team will have 1 win.
Sample 2. You missed all the games (k = 3). As d_1 = 0 and d_2 = 0, and there is a way to play three games with no winner of tournament (described in the previous sample), the answer is "yes".
Sample 3. You missed 4 matches, and d_1 = 1, d_2 = 0. These four matches can be: 1-2 (win 2), 1-3 (win 3), 1-2 (win 1), 1-3 (win 1). Currently the first team has 2 wins, the second team has 1 win, the third team has 1 win. Two remaining matches can be: 1-2 (win 2), 1-3 (win 3). In the end all the teams have equal number of wins (2 wins).
"""
|
def fwKUl():
def main():
t = int(input())
for z in range(t):
n, k, d1, d2 = map(int, input().split())
if n % 3 != 0:
print('no')
continue
f = 0
for i in [-1, +1]:
for j in [-1, +1]:
w = (k - i * d1 - j * d2)
if f == 0 and (w % 3 == 0) and (n//3)>=(w//3)>=0 and (n//3)>=(w//3 + i * d1)>=0 and (n//3)>=(w//3 + j * d2)>=0:
print('yes')
f = 1
if f == 0:
print('no')
main() | 5
3 0 0 0
3 3 0 0
6 4 1 0
6 3 3 0
3 3 3 2
| interview |
def ImEnX():
"""Harry Water, Ronaldo, Her-my-oh-knee and their friends have started a new school year at their MDCS School of Speechcraft and Misery. At the time, they are very happy to have seen each other after a long time. The sun is shining, birds are singing, flowers are blooming, and their Potions class teacher, professor Snipe is sulky as usual. Due to his angst fueled by disappointment in his own life, he has given them a lot of homework in Potions class.
Each of the n students has been assigned a single task. Some students do certain tasks faster than others. Thus, they want to redistribute the tasks so that each student still does exactly one task, and that all tasks are finished. Each student has their own laziness level, and each task has its own difficulty level. Professor Snipe is trying hard to improve their work ethics, so each studentβs laziness level is equal to their taskβs difficulty level. Both sets of values are given by the sequence a, where a_{i} represents both the laziness level of the i-th student and the difficulty of his task.
The time a student needs to finish a task is equal to the product of their laziness level and the taskβs difficulty. They are wondering, what is the minimum possible total time they must spend to finish all tasks if they distribute them in the optimal way. Each person should receive one task and each task should be given to one person. Print the answer modulo 10 007.
-----Input-----
The first line of input contains integer n (1 β€ n β€ 100 000)Β β the number of tasks. The next n lines contain exactly one integer number a_{i} (1 β€ a_{i} β€ 100 000)Β β both the difficulty of the initial task and the laziness of the i-th students.
-----Output-----
Print the minimum total time to finish all tasks modulo 10 007.
-----Example-----
Input
2
1
3
Output
6
-----Note-----
In the first sample, if the students switch their tasks, they will be able to finish them in 3 + 3 = 6 time units.
"""
|
def ImEnX():
n=int(input())
a=sorted(int(input()) for _ in range(n))
print(sum(a[i]*a[-i-1] for i in range(n))%10007) | 2
1
3
| interview |
def IoQzH():
"""You are playing a variation of game 2048. Initially you have a multiset $s$ of $n$ integers. Every integer in this multiset is a power of two.
You may perform any number (possibly, zero) operations with this multiset.
During each operation you choose two equal integers from $s$, remove them from $s$ and insert the number equal to their sum into $s$.
For example, if $s = \{1, 2, 1, 1, 4, 2, 2\}$ and you choose integers $2$ and $2$, then the multiset becomes $\{1, 1, 1, 4, 4, 2\}$.
You win if the number $2048$ belongs to your multiset. For example, if $s = \{1024, 512, 512, 4\}$ you can win as follows: choose $512$ and $512$, your multiset turns into $\{1024, 1024, 4\}$. Then choose $1024$ and $1024$, your multiset turns into $\{2048, 4\}$ and you win.
You have to determine if you can win this game.
You have to answer $q$ independent queries.
-----Input-----
The first line contains one integer $q$ ($1 \le q \le 100$) β the number of queries.
The first line of each query contains one integer $n$ ($1 \le n \le 100$) β the number of elements in multiset.
The second line of each query contains $n$ integers $s_1, s_2, \dots, s_n$ ($1 \le s_i \le 2^{29}$) β the description of the multiset. It is guaranteed that all elements of the multiset are powers of two.
-----Output-----
For each query print YES if it is possible to obtain the number $2048$ in your multiset, and NO 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 answer).
-----Example-----
Input
6
4
1024 512 64 512
1
2048
3
64 512 2
2
4096 4
7
2048 2 2048 2048 2048 2048 2048
2
2048 4096
Output
YES
YES
NO
NO
YES
YES
-----Note-----
In the first query you can win as follows: choose $512$ and $512$, and $s$ turns into $\{1024, 64, 1024\}$. Then choose $1024$ and $1024$, and $s$ turns into $\{2048, 64\}$ and you win.
In the second query $s$ contains $2048$ initially.
"""
|
def IoQzH():
for i in range(int(input())):
n=int(input())
s=list(map(int,input().split()))
a=0
for i in s:
if i<2049:a+=i
if a<2048:print("NO")
else:print("YES") | 6
4
1024 512 64 512
1
2048
3
64 512 2
2
4096 4
7
2048 2 2048 2048 2048 2048 2048
2
2048 4096
| interview |
def VcnkR():
"""A penguin Rocher has $n$ sticks. He has exactly one stick with length $i$ for all $1 \le i \le n$.
He can connect some sticks. If he connects two sticks that have lengths $a$ and $b$, he gets one stick with length $a + b$. Two sticks, that were used in the operation disappear from his set and the new connected stick appears in his set and can be used for the next connections.
He wants to create the maximum number of sticks that have the same length. It is not necessary to make all sticks have the same length, some sticks can have the other length. How many sticks with the equal length he can create?
-----Input-----
The input consists of multiple test cases. The first line contains a single integer $t$ ($1 \le t \le 1000$)Β β the number of test cases. Next $t$ lines contain descriptions of test cases.
For each test case, the only line contains a single integer $n$ ($1 \le n \le 10^{9}$).
-----Output-----
For each test case, print a single integer Β β the answer to the problem.
-----Example-----
Input
4
1
2
3
4
Output
1
1
2
2
-----Note-----
In the third case, he can connect two sticks with lengths $1$ and $2$ and he will get one stick with length $3$. So, he will have two sticks with lengths $3$.
In the fourth case, he can connect two sticks with lengths $1$ and $3$ and he will get one stick with length $4$. After that, he will have three sticks with lengths $\{2, 4, 4\}$, so two sticks have the same length, and one stick has the other length.
"""
|
def VcnkR():
for __ in range(int(input())):
n = int(input())
print((n + 1) // 2) | 4
1
2
3
4
| interview |
def NVzlR():
"""You are given an array $a$ of length $n$, which initially is a permutation of numbers from $1$ to $n$. In one operation, you can choose an index $i$ ($1 \leq i < n$) such that $a_i < a_{i + 1}$, and remove either $a_i$ or $a_{i + 1}$ from the array (after the removal, the remaining parts are concatenated).
For example, if you have the array $[1, 3, 2]$, you can choose $i = 1$ (since $a_1 = 1 < a_2 = 3$), then either remove $a_1$ which gives the new array $[3, 2]$, or remove $a_2$ which gives the new array $[1, 2]$.
Is it possible to make the length of this array equal to $1$ with these operations?
-----Input-----
The first line contains a single integer $t$ ($1 \leq t \leq 2 \cdot 10^4$) Β β the number of test cases. The description of the test cases follows.
The first line of each test case contains a single integer $n$ ($2 \leq n \leq 3 \cdot 10^5$) Β β the length of the array.
The second line of each test case contains $n$ integers $a_1$, $a_2$, ..., $a_n$ ($1 \leq a_i \leq n$, $a_i$ are pairwise distinct)Β β elements of the array.
It is guaranteed that the sum of $n$ over all test cases doesn't exceed $3 \cdot 10^5$.
-----Output-----
For each test case, output on a single line the word "YES" if it is possible to reduce the array to a single element using the aforementioned operation, or "NO" if it is impossible to do so.
-----Example-----
Input
4
3
1 2 3
4
3 1 2 4
3
2 3 1
6
2 4 6 1 3 5
Output
YES
YES
NO
YES
-----Note-----
For the first two test cases and the fourth test case, we can operate as follow (the bolded elements are the pair chosen for that operation):
$[\text{1}, \textbf{2}, \textbf{3}] \rightarrow [\textbf{1}, \textbf{2}] \rightarrow [\text{1}]$
$[\text{3}, \textbf{1}, \textbf{2}, \text{4}] \rightarrow [\text{3}, \textbf{1}, \textbf{4}] \rightarrow [\textbf{3}, \textbf{4}] \rightarrow [\text{4}]$
$[\textbf{2}, \textbf{4}, \text{6}, \text{1}, \text{3}, \text{5}] \rightarrow [\textbf{4}, \textbf{6}, \text{1}, \text{3}, \text{5}] \rightarrow [\text{4}, \text{1}, \textbf{3}, \textbf{5}] \rightarrow [\text{4}, \textbf{1}, \textbf{5}] \rightarrow [\textbf{4}, \textbf{5}] \rightarrow [\text{4}]$
"""
|
def NVzlR():
t = int(input())
for case in range(t):
n = int(input())
arr = list(map(int, input().split()))
if arr[-1] > arr[0]:
print("YES")
else:
print("NO") | 4
3
1 2 3
4
3 1 2 4
3
2 3 1
6
2 4 6 1 3 5
| interview |
def ZFSBx():
"""You have a rectangular chocolate bar consisting of n Γ m single squares. You want to eat exactly k squares, so you may need to break the chocolate bar.
In one move you can break any single rectangular piece of chocolate in two rectangular pieces. You can break only by lines between squares: horizontally or vertically. The cost of breaking is equal to square of the break length.
For example, if you have a chocolate bar consisting of 2 Γ 3 unit squares then you can break it horizontally and get two 1 Γ 3 pieces (the cost of such breaking is 3^2 = 9), or you can break it vertically in two ways and get two pieces: 2 Γ 1 and 2 Γ 2 (the cost of such breaking is 2^2 = 4).
For several given values n, m and k find the minimum total cost of breaking. You can eat exactly k squares of chocolate if after all operations of breaking there is a set of rectangular pieces of chocolate with the total size equal to k squares. The remaining nΒ·m - k squares are not necessarily form a single rectangular piece.
-----Input-----
The first line of the input contains a single integer t (1 β€ t β€ 40910)Β β the number of values n, m and k to process.
Each of the next t lines contains three integers n, m and k (1 β€ n, m β€ 30, 1 β€ k β€ min(nΒ·m, 50))Β β the dimensions of the chocolate bar and the number of squares you want to eat respectively.
-----Output-----
For each n, m and k print the minimum total cost needed to break the chocolate bar, in order to make it possible to eat exactly k squares.
-----Examples-----
Input
4
2 2 1
2 2 3
2 2 2
2 2 4
Output
5
5
4
0
-----Note-----
In the first query of the sample one needs to perform two breaks: to split 2 Γ 2 bar into two pieces of 2 Γ 1 (cost is 2^2 = 4), to split the resulting 2 Γ 1 into two 1 Γ 1 pieces (cost is 1^2 = 1).
In the second query of the sample one wants to eat 3 unit squares. One can use exactly the same strategy as in the first query of the sample.
"""
|
def ZFSBx():
mem = [[[0 for i in range(51)] for j in range(31)] for k in range(31)]
def f(n, m, k):
if mem[n][m][k]:
return mem[n][m][k]
if (n*m == k) or (k == 0):
return 0
cost = 10**9
for x in range(1, n//2 + 1):
for z in range(k+1):
cost = min(cost, m*m + f(n-x, m, k-z) + f(x, m, z))
for y in range(1, m//2 + 1):
for z in range(k+1):
cost = min(cost, n*n + f(n, m-y, k-z) + f(n, y, z))
mem[n][m][k] = cost
return cost
t = int(input())
for i in range(t):
n, m, k = list(map(int, input().split()))
print(f(n, m, k))
| 4
2 2 1
2 2 3
2 2 2
2 2 4
| interview |
def mKRYu():
"""Dark is going to attend Motarack's birthday. Dark decided that the gift he is going to give to Motarack is an array $a$ of $n$ non-negative integers.
Dark created that array $1000$ years ago, so some elements in that array disappeared. Dark knows that Motarack hates to see an array that has two adjacent elements with a high absolute difference between them. He doesn't have much time so he wants to choose an integer $k$ ($0 \leq k \leq 10^{9}$) and replaces all missing elements in the array $a$ with $k$.
Let $m$ be the maximum absolute difference between all adjacent elements (i.e. the maximum value of $|a_i - a_{i+1}|$ for all $1 \leq i \leq n - 1$) in the array $a$ after Dark replaces all missing elements with $k$.
Dark should choose an integer $k$ so that $m$ is minimized. Can you help him?
-----Input-----
The input consists of multiple test cases. The first line contains a single integer $t$ ($1 \leq t \leq 10^4$) Β β the number of test cases. The description of the test cases follows.
The first line of each test case contains one integer $n$ ($2 \leq n \leq 10^{5}$)Β β the size of the array $a$.
The second line of each test case contains $n$ integers $a_1, a_2, \ldots, a_n$ ($-1 \leq a_i \leq 10 ^ {9}$). If $a_i = -1$, then the $i$-th integer is missing. It is guaranteed that at least one integer is missing in every test case.
It is guaranteed, that the sum of $n$ for all test cases does not exceed $4 \cdot 10 ^ {5}$.
-----Output-----
Print the answers for each test case in the following format:
You should print two integers, the minimum possible value of $m$ and an integer $k$ ($0 \leq k \leq 10^{9}$) that makes the maximum absolute difference between adjacent elements in the array $a$ equal to $m$.
Make sure that after replacing all the missing elements with $k$, the maximum absolute difference between adjacent elements becomes $m$.
If there is more than one possible $k$, you can print any of them.
-----Example-----
Input
7
5
-1 10 -1 12 -1
5
-1 40 35 -1 35
6
-1 -1 9 -1 3 -1
2
-1 -1
2
0 -1
4
1 -1 3 -1
7
1 -1 7 5 2 -1 5
Output
1 11
5 35
3 6
0 42
0 0
1 2
3 4
-----Note-----
In the first test case after replacing all missing elements with $11$ the array becomes $[11, 10, 11, 12, 11]$. The absolute difference between any adjacent elements is $1$. It is impossible to choose a value of $k$, such that the absolute difference between any adjacent element will be $\leq 0$. So, the answer is $1$.
In the third test case after replacing all missing elements with $6$ the array becomes $[6, 6, 9, 6, 3, 6]$. $|a_1 - a_2| = |6 - 6| = 0$; $|a_2 - a_3| = |6 - 9| = 3$; $|a_3 - a_4| = |9 - 6| = 3$; $|a_4 - a_5| = |6 - 3| = 3$; $|a_5 - a_6| = |3 - 6| = 3$.
So, the maximum difference between any adjacent elements is $3$.
"""
|
def mKRYu():
for _ in range(int(input())):
n=int(input())
a=list(map(int,input().split()))
ans,small,big=0,2*10**9,-1
for i in range(len(a)-1):
if a[i]==-1 and a[i+1]!=-1:
small=min(small, a[i+1])
big=max(big, a[i+1])
if a[i]!=-1 and a[i+1]==-1:
small = min(small, a[i])
big = max(big, a[i])
if a[i]!=-1 and a[i+1]!=-1:
ans=max(ans, abs(a[i]-a[i+1]))
if big==-1:print(ans, 0)
else:
x=(small+big)//2
ans=max(ans, abs(big-x))
ans=max(ans, abs(x-small))
print(ans, x) | 7
5
-1 10 -1 12 -1
5
-1 40 35 -1 35
6
-1 -1 9 -1 3 -1
2
-1 -1
2
0 -1
4
1 -1 3 -1
7
1 -1 7 5 2 -1 5
| interview |
def UkDLy():
"""In order to celebrate Twice's 5th anniversary, Tzuyu and Sana decided to play a game.
Tzuyu gave Sana two integers $a$ and $b$ and a really important quest.
In order to complete the quest, Sana has to output the smallest possible value of ($a \oplus x$) + ($b \oplus x$) for any given $x$, where $\oplus$ denotes the bitwise XOR operation.
-----Input-----
Each test contains multiple test cases. The first line contains the number of test cases $t$ ($1 \le t \le 10^{4}$). Description of the test cases follows.
The only line of each test case contains two integers $a$ and $b$ ($1 \le a, b \le 10^{9}$).
-----Output-----
For each testcase, output the smallest possible value of the given expression.
-----Example-----
Input
6
6 12
4 9
59 832
28 14
4925 2912
1 1
Output
10
13
891
18
6237
0
-----Note-----
For the first test case Sana can choose $x=4$ and the value will be ($6 \oplus 4$) + ($12 \oplus 4$) = $2 + 8$ = $10$. It can be shown that this is the smallest possible value.
"""
|
def UkDLy():
n = int(input())
for _ in range(n):
a, b = list(map(int, input().split()))
print(a ^ b)
| 6
6 12
4 9
59 832
28 14
4925 2912
1 1
| interview |
def GwuxB():
"""You are given a permutation $p_1, p_2, \dots, p_n$. Recall that sequence of $n$ integers is called a permutation if it contains all integers from $1$ to $n$ exactly once.
Find three indices $i$, $j$ and $k$ such that: $1 \le i < j < k \le n$; $p_i < p_j$ and $p_j > p_k$. Or say that there are no such indices.
-----Input-----
The first line contains a single integer $T$ ($1 \le T \le 200$)Β β the number of test cases.
Next $2T$ lines contain test casesΒ β two lines per test case. The first line of each test case contains the single integer $n$ ($3 \le n \le 1000$)Β β the length of the permutation $p$.
The second line contains $n$ integers $p_1, p_2, \dots, p_n$ ($1 \le p_i \le n$; $p_i \neq p_j$ if $i \neq j$)Β β the permutation $p$.
-----Output-----
For each test case: if there are such indices $i$, $j$ and $k$, print YES (case insensitive) and the indices themselves; if there are no such indices, print NO (case insensitive).
If there are multiple valid triples of indices, print any of them.
-----Example-----
Input
3
4
2 1 4 3
6
4 6 1 2 5 3
5
5 3 1 2 4
Output
YES
2 3 4
YES
3 5 6
NO
"""
| import sys
import math
import random
def GwuxB():
#from queue import *
#sys.setrecursionlimit(int(1e6))
input = sys.stdin.readline
############ ---- USER DEFINED INPUT FUNCTIONS ---- ############
def inp():
return(int(input()))
def inara():
return(list(map(int,input().split())))
def insr():
s = input()
return(list(s[:len(s) - 1]))
def invr():
return(list(map(int,input().split())))
################################################################
############ ---- THE ACTUAL CODE STARTS BELOW ---- ############
t=inp()
for _ in range(t):
n=inp()
ara=inara()
ans=[]
for i in range(1,n-1):
if ara[i]>ara[i-1] and ara[i]>ara[i+1]:
ans.append(i)
ans.append(i+1)
ans.append(i+2)
break
if len(ans)==0:
print("NO")
else:
print("YES")
print(*ans)
| 3
4
2 1 4 3
6
4 6 1 2 5 3
5
5 3 1 2 4
| interview |
def DCany():
"""Polycarp wants to assemble his own keyboard. Layouts with multiple rows are too complicated for him β his keyboard will consist of only one row, where all $26$ lowercase Latin letters will be arranged in some order.
Polycarp uses the same password $s$ on all websites where he is registered (it is bad, but he doesn't care). He wants to assemble a keyboard that will allow to type this password very easily. He doesn't like to move his fingers while typing the password, so, for each pair of adjacent characters in $s$, they should be adjacent on the keyboard. For example, if the password is abacaba, then the layout cabdefghi... is perfect, since characters a and c are adjacent on the keyboard, and a and b are adjacent on the keyboard. It is guaranteed that there are no two adjacent equal characters in $s$, so, for example, the password cannot be password (two characters s are adjacent).
Can you help Polycarp with choosing the perfect layout of the keyboard, if it is possible?
-----Input-----
The first line contains one integer $T$ ($1 \le T \le 1000$) β the number of test cases.
Then $T$ lines follow, each containing one string $s$ ($1 \le |s| \le 200$) representing the test case. $s$ consists of lowercase Latin letters only. There are no two adjacent equal characters in $s$.
-----Output-----
For each test case, do the following:
if it is impossible to assemble a perfect keyboard, print NO (in upper case, it matters in this problem); otherwise, print YES (in upper case), and then a string consisting of $26$ lowercase Latin letters β the perfect layout. Each Latin letter should appear in this string exactly once. If there are multiple answers, print any of them.
-----Example-----
Input
5
ababa
codedoca
abcda
zxzytyz
abcdefghijklmnopqrstuvwxyza
Output
YES
bacdefghijklmnopqrstuvwxyz
YES
edocabfghijklmnpqrstuvwxyz
NO
YES
xzytabcdefghijklmnopqrsuvw
NO
"""
|
def DCany():
T = int(input())
def solve(S):
res = [S[0]]
pos = 0 # think...
for s in S[1:]:
# can we change?
if 0 <= pos-1 < len(res) and res[pos-1] == s:
pos = pos-1
elif 0 <= pos+1 < len(res) and res[pos+1] == s:
pos = pos+1
elif pos == 0 and s not in res:
res.insert(0, s) # pos is still 0
elif pos == len(res)-1 and s not in res:
res.append(s)
pos += 1
else: return None
#print(''.join(res))
for x in range(ord('a'), ord('z')+1):
x = chr(x)
if x not in res:
res.append(x)
return ''.join(res)
for _ in range(T):
res = solve(input())
if res is None:
print('NO')
else:
print('YES')
print(res)
| 5
ababa
codedoca
abcda
zxzytyz
abcdefghijklmnopqrstuvwxyza
| interview |
def dLVYB():
"""Lee just became Master in Codeforces, and so, he went out to buy some gifts for his friends. He bought $n$ integers, now it's time to distribute them between his friends rationally...
Lee has $n$ integers $a_1, a_2, \ldots, a_n$ in his backpack and he has $k$ friends. Lee would like to distribute all integers in his backpack between his friends, such that the $i$-th friend will get exactly $w_i$ integers and each integer will be handed over to exactly one friend.
Let's define the happiness of a friend as the sum of the maximum and the minimum integer he'll get.
Lee would like to make his friends as happy as possible, in other words, he'd like to maximize the sum of friends' happiness. Now he asks you to calculate the maximum sum of friends' happiness.
-----Input-----
The first line contains one integer $t$ ($1 \le t \le 10^4$)Β β the number of test cases.
Next $3t$ lines contain test casesΒ β one per three lines.
The first line of each test case contains two integers $n$ and $k$ ($1 \le n \le 2 \cdot 10^5$; $1 \le k \le n$)Β β the number of integers Lee has and the number of Lee's friends.
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 integers Lee has.
The third line contains $k$ integers $w_1, w_2, \ldots, w_k$ ($1 \le w_i \le n$; $w_1 + w_2 + \ldots + w_k = n$)Β β the number of integers Lee wants to give to each friend.
It's guaranteed that the sum of $n$ over test cases is less than or equal to $2 \cdot 10^5$.
-----Output-----
For each test case, print a single integerΒ β the maximum sum of happiness Lee can achieve.
-----Example-----
Input
3
4 2
1 13 7 17
1 3
6 2
10 10 10 10 11 11
3 3
4 4
1000000000 1000000000 1000000000 1000000000
1 1 1 1
Output
48
42
8000000000
-----Note-----
In the first test case, Lee should give the greatest integer to the first friend (his happiness will be $17 + 17$) and remaining integers to the second friend (his happiness will be $13 + 1$).
In the second test case, Lee should give $\{10, 10, 11\}$ to the first friend and to the second friend, so the total happiness will be equal to $(11 + 10) + (11 + 10)$
In the third test case, Lee has four friends and four integers, it doesn't matter how he distributes the integers between his friends.
"""
|
def dLVYB():
def solve():
n, k = map(int,input().split())
lst1 = list(map(int,input().split()))
lst1.sort(reverse=True)
ind = 0
ans = 0
lst2 = list(map(int,input().split()))
lst2.sort()
for i in range(k):
lst2[i] -= 1
if lst2[i] == 0: ans += lst1[ind]
ans += lst1[ind]
ind += 1
lst2.sort()
for i in lst2:
if i != 0:
ind += i - 1
ans += lst1[ind]
ind += 1
print(ans)
for i in range(int(input())):
solve() | 3
4 2
1 13 7 17
1 3
6 2
10 10 10 10 11 11
3 3
4 4
1000000000 1000000000 1000000000 1000000000
1 1 1 1
| interview |
def DKcWL():
"""You and your friend are playing the game Mortal Kombat XI. You are trying to pass a challenge tower. There are $n$ bosses in this tower, numbered from $1$ to $n$. The type of the $i$-th boss is $a_i$. If the $i$-th boss is easy then its type is $a_i = 0$, otherwise this boss is hard and its type is $a_i = 1$.
During one session, either you or your friend can kill one or two bosses (neither you nor your friend can skip the session, so the minimum number of bosses killed during one session is at least one). After your friend session, your session begins, then again your friend session begins, your session begins, and so on. The first session is your friend's session.
Your friend needs to get good because he can't actually kill hard bosses. To kill them, he uses skip points. One skip point can be used to kill one hard boss.
Your task is to find the minimum number of skip points your friend needs to use so you and your friend kill all $n$ bosses in the given order.
For example: suppose $n = 8$, $a = [1, 0, 1, 1, 0, 1, 1, 1]$. Then the best course of action is the following:
your friend kills two first bosses, using one skip point for the first boss; you kill the third and the fourth bosses; your friend kills the fifth boss; you kill the sixth and the seventh bosses; your friend kills the last boss, using one skip point, so the tower is completed using two skip points.
You have to answer $t$ independent test cases.
-----Input-----
The first line of the input contains one integer $t$ ($1 \le t \le 2 \cdot 10^4$) β the number of test cases. Then $t$ test cases follow.
The first line of the test case contains one integer $n$ ($1 \le n \le 2 \cdot 10^5$) β the number of bosses. The second line of the test case contains $n$ integers $a_1, a_2, \dots, a_n$ ($0 \le a_i \le 1$), where $a_i$ is the type of the $i$-th boss.
It is guaranteed that the sum of $n$ does not exceed $2 \cdot 10^5$ ($\sum n \le 2 \cdot 10^5$).
-----Output-----
For each test case, print the answer: the minimum number of skip points your friend needs to use so you and your friend kill all $n$ bosses in the given order.
-----Example-----
Input
6
8
1 0 1 1 0 1 1 1
5
1 1 1 1 0
7
1 1 1 1 0 0 1
6
1 1 1 1 1 1
1
1
1
0
Output
2
2
2
2
1
0
"""
| import math
from collections import deque
from sys import stdin, stdout
from string import ascii_letters
import sys
def DKcWL():
letters = ascii_letters
input = stdin.readline
#print = stdout.write
for _ in range(int(input())):
n = int(input())
arr = list(map(int, input().split()))
ans = [999999999] * n
ans[0] = 1 if arr[0] == 1 else 0
if n > 1:
ans[1] = ans[0]
if n > 2:
ans[2] = ans[0]
for i in range(n):
if i + 1 >= n:
continue
if arr[i + 1] == 1:
ans[i + 1] = min(ans[i + 1], ans[i] + 1)
if i + 2 < n:
ans[i + 2] = min(ans[i + 2], ans[i] + 1)
if i + 3 < n:
ans[i + 3] = min(ans[i + 3], ans[i] + 1)
else:
ans[i + 1] = min(ans[i + 1], ans[i])
if i + 2 < n:
ans[i + 2] = min(ans[i + 2], ans[i])
if i + 3 < n:
ans[i + 3] = min(ans[i + 3], ans[i])
print(ans[-1]) | 6
8
1 0 1 1 0 1 1 1
5
1 1 1 1 0
7
1 1 1 1 0 0 1
6
1 1 1 1 1 1
1
1
1
0
| interview |
def EtbDT():
"""This problem is different from the easy version. In this version Ujan makes at most $2n$ swaps. In addition, $k \le 1000, n \le 50$ and it is necessary to print swaps themselves. You can hack this problem if you solve it. But you can hack the previous problem only if you solve both problems.
After struggling and failing many times, Ujan decided to try to clean up his house again. He decided to get his strings in order first.
Ujan has two distinct strings $s$ and $t$ of length $n$ consisting of only of lowercase English characters. He wants to make them equal. Since Ujan is lazy, he will perform the following operation at most $2n$ times: he takes two positions $i$ and $j$ ($1 \le i,j \le n$, the values $i$ and $j$ can be equal or different), and swaps the characters $s_i$ and $t_j$.
Ujan's goal is to make the strings $s$ and $t$ equal. He does not need to minimize the number of performed operations: any sequence of operations of length $2n$ or shorter is suitable.
-----Input-----
The first line contains a single integer $k$ ($1 \leq k \leq 1000$), the number of test cases.
For each of the test cases, the first line contains a single integer $n$ ($2 \leq n \leq 50$), the length of the strings $s$ and $t$.
Each of the next two lines contains the strings $s$ and $t$, each having length exactly $n$. The strings consist only of lowercase English letters. It is guaranteed that strings are different.
-----Output-----
For each test case, output "Yes" if Ujan can make the two strings equal with at most $2n$ operations and "No" otherwise. You can print each letter in any case (upper or lower).
In the case of "Yes" print $m$ ($1 \le m \le 2n$) on the next line, where $m$ is the number of swap operations to make the strings equal. Then print $m$ lines, each line should contain two integers $i, j$ ($1 \le i, j \le n$) meaning that Ujan swaps $s_i$ and $t_j$ during the corresponding operation. You do not need to minimize the number of operations. Any sequence of length not more than $2n$ is suitable.
-----Example-----
Input
4
5
souse
houhe
3
cat
dog
2
aa
az
3
abc
bca
Output
Yes
1
1 4
No
No
Yes
3
1 2
3 1
2 3
"""
|
def EtbDT():
for _ in range(int(input())):
n = int(input())
s = input()
t = input()
d = {}
for i in range(ord('a'), ord('z') + 1):
d[chr(i)] = 0
for cs in s:
d[cs] += 1
for ct in t:
d[ct] += 1
ok = True
for e in d:
if d[e] % 2 == 1:
ok = False
if not ok:
print("No")
else:
print("Yes")
changes = []
s, t = list(s), list(t)
for i in range(n-1):
if s[i] != t[i]:
r = (0, -1)
for j in range(i+1, n):
if s[j] == t[i]:
r = (j, 0)
for j in range(i+1, n):
if t[j] == t[i]:
r = (j, 1)
if r[1] == 0:
changes += [(r[0], i+1), (i, i+1)]
s[r[0]], t[i+1] = t[i+1], s[r[0]]
s[i], t[i+1] = t[i+1], s[i]
elif r[1] == 1:
changes += [(i, r[0])]
s[i], t[r[0]] = t[r[0]], s[i]
print(len(changes))
for change in changes:
x, y = change
print(x+1, y+1) | 4
5
souse
houhe
3
cat
dog
2
aa
az
3
abc
bca
| interview |
def JuoOI():
"""You have a string $s$ consisting of $n$ characters. Each character is either 0 or 1.
You can perform operations on the string. Each operation consists of two steps: select an integer $i$ from $1$ to the length of the string $s$, then delete the character $s_i$ (the string length gets reduced by $1$, the indices of characters to the right of the deleted one also get reduced by $1$); if the string $s$ is not empty, delete the maximum length prefix consisting of the same characters (the indices of the remaining characters and the string length get reduced by the length of the deleted prefix).
Note that both steps are mandatory in each operation, and their order cannot be changed.
For example, if you have a string $s =$ 111010, the first operation can be one of the following: select $i = 1$: we'll get 111010 $\rightarrow$ 11010 $\rightarrow$ 010; select $i = 2$: we'll get 111010 $\rightarrow$ 11010 $\rightarrow$ 010; select $i = 3$: we'll get 111010 $\rightarrow$ 11010 $\rightarrow$ 010; select $i = 4$: we'll get 111010 $\rightarrow$ 11110 $\rightarrow$ 0; select $i = 5$: we'll get 111010 $\rightarrow$ 11100 $\rightarrow$ 00; select $i = 6$: we'll get 111010 $\rightarrow$ 11101 $\rightarrow$ 01.
You finish performing operations when the string $s$ becomes empty. What is the maximum number of operations you can perform?
-----Input-----
The first line contains a single integer $t$ ($1 \le t \le 1000$)Β β the number of test cases.
The first line of each test case contains a single integer $n$ ($1 \le n \le 2 \cdot 10^5$)Β β the length of the string $s$.
The second line contains string $s$ of $n$ characters. Each character is either 0 or 1.
It's guaranteed that the total sum of $n$ over test cases doesn't exceed $2 \cdot 10^5$.
-----Output-----
For each test case, print a single integerΒ β the maximum number of operations you can perform.
-----Example-----
Input
5
6
111010
1
0
1
1
2
11
6
101010
Output
3
1
1
1
3
-----Note-----
In the first test case, you can, for example, select $i = 2$ and get string 010 after the first operation. After that, you can select $i = 3$ and get string 1. Finally, you can only select $i = 1$ and get empty string.
"""
| from itertools import groupby
def JuoOI():
def main():
N = int(input())
S = input()
C = [len(list(x[1])) for x in groupby(S)]
M = len(C)
dup_idx = []
for i, c in enumerate(C):
if c > 1:
dup_idx.append(i)
dup_idx.reverse()
curr = 0
while dup_idx:
i = dup_idx[-1]
if i < curr:
dup_idx.pop()
continue
C[i] -= 1
if C[i] == 1:
dup_idx.pop()
curr += 1
ans = curr + (M-curr+1)//2
print(ans)
def __starting_point():
for __ in [0]*int(input()):
main()
__starting_point() | 5
6
111010
1
0
1
1
2
11
6
101010
| interview |
def QLNDS():
"""Bertown is a city with $n$ buildings in a straight line.
The city's security service discovered that some buildings were mined. A map was compiled, which is a string of length $n$, where the $i$-th character is "1" if there is a mine under the building number $i$ and "0" otherwise.
Bertown's best sapper knows how to activate mines so that the buildings above them are not damaged. When a mine under the building numbered $x$ is activated, it explodes and activates two adjacent mines under the buildings numbered $x-1$ and $x+1$ (if there were no mines under the building, then nothing happens). Thus, it is enough to activate any one mine on a continuous segment of mines to activate all the mines of this segment. For manual activation of one mine, the sapper takes $a$ coins. He can repeat this operation as many times as you want.
Also, a sapper can place a mine under a building if it wasn't there. For such an operation, he takes $b$ coins. He can also repeat this operation as many times as you want.
The sapper can carry out operations in any order.
You want to blow up all the mines in the city to make it safe. Find the minimum number of coins that the sapper will have to pay so that after his actions there are no mines left in the city.
-----Input-----
The first line contains one positive integer $t$ ($1 \le t \le 10^5$)Β β the number of test cases. Then $t$ test cases follow.
Each test case begins with a line containing two integers $a$ and $b$ ($1 \le a, b \le 1000$)Β β the cost of activating and placing one mine, respectively.
The next line contains a map of mines in the cityΒ β a string consisting of zeros and ones.
The sum of the string lengths for all test cases does not exceed $10^5$.
-----Output-----
For each test case, output one integerΒ β the minimum number of coins that the sapper will have to pay.
-----Example-----
Input
2
1 1
01000010
5 1
01101110
Output
2
6
-----Note-----
In the second test case, if we place a mine under the fourth building and then activate it, then all mines on the field are activated. The cost of such operations is six, $b=1$ coin for placing a mine and $a=5$ coins for activating.
"""
|
def QLNDS():
t = int(input())
for case in range(t):
a, b = list(map(int, input().split()))
s = input()
z = 10000
total = 0
act = False
for i in range(len(s)):
cur = s[i]
if cur == '0':
z += 1
act = False
else:
if not act:
act = True
total += min(a, b * z)
z = 0
print(total)
| 2
1 1
01000010
5 1
01101110
| interview |
def OIhNp():
"""You're given an array $a$ of $n$ integers, such that $a_1 + a_2 + \cdots + a_n = 0$.
In one operation, you can choose two different indices $i$ and $j$ ($1 \le i, j \le n$), decrement $a_i$ by one and increment $a_j$ by one. If $i < j$ this operation is free, otherwise it costs one coin.
How many coins do you have to spend in order to make all elements equal to $0$?
-----Input-----
Each test contains multiple test cases. The first line contains the number of test cases $t$ ($1 \le t \le 5000$). Description of the test cases follows.
The first line of each test case contains an integer $n$ ($1 \le n \le 10^5$) Β β the number of elements.
The next line contains $n$ integers $a_1, \ldots, a_n$ ($-10^9 \le a_i \le 10^9$). It is given that $\sum_{i=1}^n a_i = 0$.
It is guaranteed that the sum of $n$ over all test cases does not exceed $10^5$.
-----Output-----
For each test case, print the minimum number of coins we have to spend in order to make all elements equal to $0$.
-----Example-----
Input
7
4
-3 5 -3 1
2
1 -1
4
-3 2 -3 4
4
-1 1 1 -1
7
-5 7 -6 -4 17 -13 4
6
-1000000000 -1000000000 -1000000000 1000000000 1000000000 1000000000
1
0
Output
3
0
4
1
8
3000000000
0
-----Note-----
Possible strategy for the first test case: Do $(i=2, j=3)$ three times (free), $a = [-3, 2, 0, 1]$. Do $(i=2, j=1)$ two times (pay two coins), $a = [-1, 0, 0, 1]$. Do $(i=4, j=1)$ one time (pay one coin), $a = [0, 0, 0, 0]$.
"""
|
def OIhNp():
t=int(input())
while t>0 :
n=int(input())
a=list(map(int,input().split()))
an=0
s=0
for i in a :
if s+i>=0 :
s+=i
else :
s+=i
an-=s
s=0
print(an)
t-=1 | 7
4
-3 5 -3 1
2
1 -1
4
-3 2 -3 4
4
-1 1 1 -1
7
-5 7 -6 -4 17 -13 4
6
-1000000000 -1000000000 -1000000000 1000000000 1000000000 1000000000
1
0
| interview |
def PLXOI():
"""Phoenix loves beautiful arrays. An array is beautiful if all its subarrays of lengthΒ $k$ have the same sum. A subarray of an array is any sequence of consecutive elements.
Phoenix currently has an array $a$ of length $n$. He wants to insert some number of integers, possibly zero, into his array such that it becomes beautiful. The inserted integers must be between $1$ and $n$ inclusive. Integers may be inserted anywhere (even before the first or after the last element), and he is not trying to minimize the number of inserted integers.
-----Input-----
The input consists of multiple test cases. The first line contains an integer $t$ ($1 \le t \le 50$)Β β the number of test cases.
The first line of each test case contains two integers $n$ and $k$ ($1 \le k \le n \le 100$).
The second line of each test case contains $n$ space-separated integers ($1 \le a_i \le n$)Β β the array that Phoenix currently has. This array may or may not be already beautiful.
-----Output-----
For each test case, if it is impossible to create a beautiful array, print -1. Otherwise, print two lines.
The first line should contain the length of the beautiful array $m$ ($n \le m \le 10^4$). You don't need to minimize $m$.
The second line should contain $m$ space-separated integers ($1 \le b_i \le n$)Β β a beautiful array that Phoenix can obtain after inserting some, possibly zero, integers into his array $a$. You may print integers that weren't originally in array $a$.
If there are multiple solutions, print any. It's guaranteed that if we can make array $a$ beautiful, we can always make it with resulting length no more than $10^4$.
-----Example-----
Input
4
4 2
1 2 2 1
4 3
1 2 2 1
3 2
1 2 3
4 4
4 3 4 2
Output
5
1 2 1 2 1
4
1 2 2 1
-1
7
4 3 2 1 4 3 2
-----Note-----
In the first test case, we can make array $a$ beautiful by inserting the integer $1$ at index $3$ (in between the two existing $2$s). Now, all subarrays of length $k=2$ have the same sum $3$. There exists many other possible solutions, for example: $2, 1, 2, 1, 2, 1$ $1, 2, 1, 2, 1, 2$
In the second test case, the array is already beautiful: all subarrays of length $k=3$ have the same sum $5$.
In the third test case, it can be shown that we cannot insert numbers to make array $a$ beautiful.
In the fourth test case, the array $b$ shown is beautiful and all subarrays of length $k=4$ have the same sum $10$. There exist other solutions also.
"""
|
def PLXOI():
t = int(input())
for _ in range(t):
n, k = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
if len(set(a)) > k:
print(-1)
continue
l = list(set(a))
l.extend([1]*(k - len(l)))
print(n*k)
for _ in range(n):
print(*l, end=" ")
print()
| 4
4 2
1 2 2 1
4 3
1 2 2 1
3 2
1 2 3
4 4
4 3 4 2
| interview |
def ZkWYV():
"""The statement of this problem is the same as the statement of problem C1. The only difference is that, in problem C1, $n$ is always even, and in C2, $n$ is always odd.
You are given a regular polygon with $2 \cdot n$ vertices (it's convex and has equal sides and equal angles) and all its sides have length $1$. Let's name it as $2n$-gon.
Your task is to find the square of the minimum size such that you can embed $2n$-gon in the square. Embedding $2n$-gon in the square means that you need to place $2n$-gon in the square in such way that each point which lies inside or on a border of $2n$-gon should also lie inside or on a border of the square.
You can rotate $2n$-gon and/or the square.
-----Input-----
The first line contains a single integer $T$ ($1 \le T \le 200$)Β β the number of test cases.
Next $T$ lines contain descriptions of test casesΒ β one per line. Each line contains single odd integer $n$ ($3 \le n \le 199$). Don't forget you need to embed $2n$-gon, not an $n$-gon.
-----Output-----
Print $T$ real numbersΒ β one per test case. For each test case, print the minimum length of a side of the square $2n$-gon can be embedded in. Your answer will be considered correct if its absolute or relative error doesn't exceed $10^{-6}$.
-----Example-----
Input
3
3
5
199
Output
1.931851653
3.196226611
126.687663595
"""
| import math
def ZkWYV():
T = int(input())
for _ in range(T):
n = int(input())
diags = 1/math.sin(math.pi/2/n)
print(diags * math.cos(math.pi/4/n)) | 3
3
5
199
| interview |
def UtmXx():
"""Lee is going to fashionably decorate his house for a party, using some regular convex polygons...
Lee thinks a regular $n$-sided (convex) polygon is beautiful if and only if he can rotate it in such a way that at least one of its edges is parallel to the $OX$-axis and at least one of its edges is parallel to the $OY$-axis at the same time.
Recall that a regular $n$-sided polygon is a convex polygon with $n$ vertices such that all the edges and angles are equal.
Now he is shopping: the market has $t$ regular polygons. For each of them print YES if it is beautiful and NO otherwise.
-----Input-----
The first line contains a single integer $t$ ($1 \le t \le 10^4$)Β β the number of polygons in the market.
Each of the next $t$ lines contains a single integer $n_i$ ($3 \le n_i \le 10^9$): it means that the $i$-th polygon is a regular $n_i$-sided polygon.
-----Output-----
For each polygon, print YES if it's beautiful or NO otherwise (case insensitive).
-----Example-----
Input
4
3
4
12
1000000000
Output
NO
YES
YES
YES
-----Note-----
In the example, there are $4$ polygons in the market. It's easy to see that an equilateral triangle (a regular $3$-sided polygon) is not beautiful, a square (a regular $4$-sided polygon) is beautiful and a regular $12$-sided polygon (is shown below) is beautiful as well. [Image]
"""
|
def UtmXx():
t = int(input())
for _ in range(t):
n = int(input())
if n%4 == 0:
print("YES")
else:
print("NO") | 4
3
4
12
1000000000
| interview |
def XUSry():
"""You have a fence consisting of $n$ vertical boards. The width of each board is $1$. The height of the $i$-th board is $a_i$. You think that the fence is great if there is no pair of adjacent boards having the same height. More formally, the fence is great if and only if for all indices from $2$ to $n$, the condition $a_{i-1} \neq a_i$ holds.
Unfortunately, it is possible that now your fence is not great. But you can change it! You can increase the length of the $i$-th board by $1$, but you have to pay $b_i$ rubles for it. The length of each board can be increased any number of times (possibly, zero).
Calculate the minimum number of rubles you have to spend to make the fence great again!
You have to answer $q$ independent queries.
-----Input-----
The first line contains one integer $q$ ($1 \le q \le 3 \cdot 10^5$) β the number of queries.
The first line of each query contains one integers $n$ ($1 \le n \le 3 \cdot 10^5$) β the number of boards in the fence.
The following $n$ lines of each query contain the descriptions of the boards. The $i$-th line contains two integers $a_i$ and $b_i$ ($1 \le a_i, b_i \le 10^9$) β the length of the $i$-th board and the price for increasing it by $1$, respectively.
It is guaranteed that sum of all $n$ over all queries not exceed $3 \cdot 10^5$.
It is guaranteed that answer to each query will not exceed $10^{18}$.
-----Output-----
For each query print one integer β the minimum number of rubles you have to spend to make the fence great.
-----Example-----
Input
3
3
2 4
2 1
3 5
3
2 3
2 10
2 6
4
1 7
3 3
2 6
1000000000 2
Output
2
9
0
-----Note-----
In the first query you have to increase the length of second board by $2$. So your total costs if $2 \cdot b_2 = 2$.
In the second query you have to increase the length of first board by $1$ and the length of third board by $1$. So your total costs if $1 \cdot b_1 + 1 \cdot b_3 = 9$.
In the third query the fence is great initially, so you don't need to spend rubles.
"""
| import math
import os
import sys
def XUSry():
3
DEBUG = 'DEBUG' in os.environ
def inp():
return sys.stdin.readline().rstrip()
def dprint(*value, sep=' ', end='\n'):
if DEBUG:
print(*value, sep=sep, end=end)
INF = 10 ** 20
def solve(N, A, B):
dp = {A[0]: 0, A[0] + 1: B[0], A[0] + 2: B[0] * 2}
for i in range(1, N):
ndp = {}
h = A[i]
for ph, c in dp.items():
for inc in range(3):
nh = h + inc
if ph == nh:
continue
if nh not in ndp:
ndp[nh] = INF
ndp[nh] = min(ndp[nh], c + B[i] * inc)
dp = ndp
return min(dp.values())
def main():
Q = int(inp())
for _ in range(Q):
N = int(inp())
A = []
B = []
for _ in range(N):
a, b = [int(e) for e in inp().split()]
A.append(a)
B.append(b)
print(solve(N, A, B))
def __starting_point():
main()
__starting_point() | 3
3
2 4
2 1
3 5
3
2 3
2 10
2 6
4
1 7
3 3
2 6
1000000000 2
| interview |
def aptQq():
"""You are given a picture consisting of $n$ rows and $m$ columns. Rows are numbered from $1$ to $n$ from the top to the bottom, columns are numbered from $1$ to $m$ from the left to the right. Each cell is painted either black or white.
You think that this picture is not interesting enough. You consider a picture to be interesting if there is at least one cross in it. A cross is represented by a pair of numbers $x$ and $y$, where $1 \le x \le n$ and $1 \le y \le m$, such that all cells in row $x$ and all cells in column $y$ are painted black.
For examples, each of these pictures contain crosses:
[Image]
The fourth picture contains 4 crosses: at $(1, 3)$, $(1, 5)$, $(3, 3)$ and $(3, 5)$.
Following images don't contain crosses:
[Image]
You have a brush and a can of black paint, so you can make this picture interesting. Each minute you may choose a white cell and paint it black.
What is the minimum number of minutes you have to spend so the resulting picture contains at least one cross?
You are also asked to answer multiple independent queries.
-----Input-----
The first line contains an integer $q$ ($1 \le q \le 5 \cdot 10^4$) β the number of queries.
The first line of each query contains two integers $n$ and $m$ ($1 \le n, m \le 5 \cdot 10^4$, $n \cdot m \le 4 \cdot 10^5$) β the number of rows and the number of columns in the picture.
Each of the next $n$ lines contains $m$ characters β '.' if the cell is painted white and '*' if the cell is painted black.
It is guaranteed that $\sum n \le 5 \cdot 10^4$ and $\sum n \cdot m \le 4 \cdot 10^5$.
-----Output-----
Print $q$ lines, the $i$-th line should contain a single integer β the answer to the $i$-th query, which is the minimum number of minutes you have to spend so the resulting picture contains at least one cross.
-----Example-----
Input
9
5 5
..*..
..*..
*****
..*..
..*..
3 4
****
.*..
.*..
4 3
***
*..
*..
*..
5 5
*****
*.*.*
*****
..*.*
..***
1 4
****
5 5
.....
..*..
.***.
..*..
.....
5 3
...
.*.
.*.
***
.*.
3 3
.*.
*.*
.*.
4 4
*.**
....
*.**
*.**
Output
0
0
0
0
0
4
1
1
2
-----Note-----
The example contains all the pictures from above in the same order.
The first 5 pictures already contain a cross, thus you don't have to paint anything.
You can paint $(1, 3)$, $(3, 1)$, $(5, 3)$ and $(3, 5)$ on the $6$-th picture to get a cross in $(3, 3)$. That'll take you $4$ minutes.
You can paint $(1, 2)$ on the $7$-th picture to get a cross in $(4, 2)$.
You can paint $(2, 2)$ on the $8$-th picture to get a cross in $(2, 2)$. You can, for example, paint $(1, 3)$, $(3, 1)$ and $(3, 3)$ to get a cross in $(3, 3)$ but that will take you $3$ minutes instead of $1$.
There are 9 possible crosses you can get in minimum time on the $9$-th picture. One of them is in $(1, 1)$: paint $(1, 2)$ and $(2, 1)$.
"""
| import sys
def aptQq():
q = int(sys.stdin.readline().strip())
for t in range(0, q):
n, m = list(map(int, sys.stdin.readline().strip().split()))
L = []
R = [0] * n
C = [0] * m
for i in range (0, n):
L.append(sys.stdin.readline().strip())
for j in range (0, m):
if L[i][j] != "*":
R[i] = R[i] + 1
C[j] = C[j] + 1
ans = n + m - 1
for i in range (0, n):
for j in range (0, m):
x = 0
if L[i][j] != "*":
x = -1
ans = min([ans, R[i]+C[j]+x])
print(ans) | 9
5 5
..*..
..*..
*****
..*..
..*..
3 4
****
.*..
.*..
4 3
***
*..
*..
*..
5 5
*****
*.*.*
*****
..*.*
..***
1 4
****
5 5
.....
..*..
.***.
..*..
.....
5 3
...
.*.
.*.
***
.*.
3 3
.*.
*.*
.*.
4 4
*.**
....
*.**
*.**
| interview |
def WNRsk():
"""While doing some spring cleaning, Daniel found an old calculator that he loves so much. However, it seems like it is broken. When he tries to compute $1 + 3$ using the calculator, he gets $2$ instead of $4$. But when he tries computing $1 + 4$, he gets the correct answer, $5$. Puzzled by this mystery, he opened up his calculator and found the answer to the riddle: the full adders became half adders!
So, when he tries to compute the sum $a + b$ using the calculator, he instead gets the xorsum $a \oplus b$ (read the definition by the link: https://en.wikipedia.org/wiki/Exclusive_or).
As he saw earlier, the calculator sometimes gives the correct answer. And so, he wonders, given integers $l$ and $r$, how many pairs of integers $(a, b)$ satisfy the following conditions: $$a + b = a \oplus b$$ $$l \leq a \leq r$$ $$l \leq b \leq r$$
However, Daniel the Barman is going to the bar and will return in two hours. He tells you to solve the problem before he returns, or else you will have to enjoy being blocked.
-----Input-----
The first line contains a single integer $t$ ($1 \le t \le 100$) β the number of testcases.
Then, $t$ lines follow, each containing two space-separated integers $l$ and $r$ ($0 \le l \le r \le 10^9$).
-----Output-----
Print $t$ integers, the $i$-th integer should be the answer to the $i$-th testcase.
-----Example-----
Input
3
1 4
323 323
1 1000000
Output
8
0
3439863766
-----Note-----
$a \oplus b$ denotes the bitwise XOR of $a$ and $b$.
For the first testcase, the pairs are: $(1, 2)$, $(1, 4)$, $(2, 1)$, $(2, 4)$, $(3, 4)$, $(4, 1)$, $(4, 2)$, and $(4, 3)$.
"""
|
def WNRsk():
def solve(L, R):
res = 0
for i in range(32):
for j in range(32):
l = (L >> i) << i
r = (R >> j) << j
#print(l, r)
if l>>i&1==0 or r>>j&1==0:
continue
l -= 1<<i
r -= 1<<j
if l & r:
continue
lr = l ^ r
ma = max(i, j)
mi = min(i, j)
mask = (1<<ma)-1
p = bin(lr&mask).count("1")
ip = ma - mi - p
res += 3**mi * 2**ip
#print(l, r, mi, ip, 3**mi * 2**ip)
return res
T = int(input())
for _ in range(T):
l, r = list(map(int, input().split()))
print(solve(r+1, r+1) + solve(l, l) - solve(l, r+1) * 2)
| 3
1 4
323 323
1 1000000
| interview |
def mHSBk():
"""You are given three strings $a$, $b$ and $c$ of the same length $n$. The strings consist of lowercase English letters only. The $i$-th letter of $a$ is $a_i$, the $i$-th letter of $b$ is $b_i$, the $i$-th letter of $c$ is $c_i$.
For every $i$ ($1 \leq i \leq n$) you must swap (i.e. exchange) $c_i$ with either $a_i$ or $b_i$. So in total you'll perform exactly $n$ swap operations, each of them either $c_i \leftrightarrow a_i$ or $c_i \leftrightarrow b_i$ ($i$ iterates over all integers between $1$ and $n$, inclusive).
For example, if $a$ is "code", $b$ is "true", and $c$ is "help", you can make $c$ equal to "crue" taking the $1$-st and the $4$-th letters from $a$ and the others from $b$. In this way $a$ becomes "hodp" and $b$ becomes "tele".
Is it possible that after these swaps the string $a$ becomes exactly the same as the string $b$?
-----Input-----
The input consists of multiple test cases. The first line contains a single 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 a string of lowercase English letters $a$.
The second line of each test case contains a string of lowercase English letters $b$.
The third line of each test case contains a string of lowercase English letters $c$.
It is guaranteed that in each test case these three strings are non-empty and have the same length, which is not exceeding $100$.
-----Output-----
Print $t$ lines with answers for all test cases. For each test case:
If it is possible to make string $a$ equal to string $b$ print "YES" (without quotes), otherwise print "NO" (without quotes).
You can print either lowercase or uppercase letters in the answers.
-----Example-----
Input
4
aaa
bbb
ccc
abc
bca
bca
aabb
bbaa
baba
imi
mii
iim
Output
NO
YES
YES
NO
-----Note-----
In the first test case, it is impossible to do the swaps so that string $a$ becomes exactly the same as string $b$.
In the second test case, you should swap $c_i$ with $a_i$ for all possible $i$. After the swaps $a$ becomes "bca", $b$ becomes "bca" and $c$ becomes "abc". Here the strings $a$ and $b$ are equal.
In the third test case, you should swap $c_1$ with $a_1$, $c_2$ with $b_2$, $c_3$ with $b_3$ and $c_4$ with $a_4$. Then string $a$ becomes "baba", string $b$ becomes "baba" and string $c$ becomes "abab". Here the strings $a$ and $b$ are equal.
In the fourth test case, it is impossible to do the swaps so that string $a$ becomes exactly the same as string $b$.
"""
|
def mHSBk():
for _ in range(int(input())):
a, b, c = input(), input(), input()
n = len(a)
ok = True
for i in range(n):
if c[i] not in [a[i], b[i]]:
ok = False
print('YES' if ok else 'NO')
| 4
aaa
bbb
ccc
abc
bca
bca
aabb
bbaa
baba
imi
mii
iim
| interview |
def DnPlU():
"""A permutation of length $n$ 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).
Let $p$ be any permutation of length $n$. We define the fingerprint $F(p)$ of $p$ as the sorted array of sums of adjacent elements in $p$. More formally,
$$F(p)=\mathrm{sort}([p_1+p_2,p_2+p_3,\ldots,p_{n-1}+p_n]).$$
For example, if $n=4$ and $p=[1,4,2,3],$ then the fingerprint is given by $F(p)=\mathrm{sort}([1+4,4+2,2+3])=\mathrm{sort}([5,6,5])=[5,5,6]$.
You are given a permutation $p$ of length $n$. Your task is to find a different permutation $p'$ with the same fingerprint. Two permutations $p$ and $p'$ are considered different if there is some index $i$ such that $p_i \ne p'_i$.
-----Input-----
Each test contains multiple test cases. The first line contains the number of test cases $t$ ($1 \le t \le 668$). Description of the test cases follows.
The first line of each test case contains a single integer $n$ ($2\le n\le 100$) Β β the length of the permutation.
The second line of each test case contains $n$ integers $p_1,\ldots,p_n$ ($1\le p_i\le n$). It is guaranteed that $p$ is a permutation.
-----Output-----
For each test case, output $n$ integers $p'_1,\ldots, p'_n$ β a permutation such that $p'\ne p$ and $F(p')=F(p)$.
We can prove that for every permutation satisfying the input constraints, a solution exists.
If there are multiple solutions, you may output any.
-----Example-----
Input
3
2
1 2
6
2 1 6 5 4 3
5
2 4 3 1 5
Output
2 1
1 2 5 6 3 4
3 1 5 2 4
-----Note-----
In the first test case, $F(p)=\mathrm{sort}([1+2])=[3]$.
And $F(p')=\mathrm{sort}([2+1])=[3]$.
In the second test case, $F(p)=\mathrm{sort}([2+1,1+6,6+5,5+4,4+3])=\mathrm{sort}([3,7,11,9,7])=[3,7,7,9,11]$.
And $F(p')=\mathrm{sort}([1+2,2+5,5+6,6+3,3+4])=\mathrm{sort}([3,7,11,9,7])=[3,7,7,9,11]$.
In the third test case, $F(p)=\mathrm{sort}([2+4,4+3,3+1,1+5])=\mathrm{sort}([6,7,4,6])=[4,6,6,7]$.
And $F(p')=\mathrm{sort}([3+1,1+5,5+2,2+4])=\mathrm{sort}([4,6,7,6])=[4,6,6,7]$.
"""
|
def DnPlU():
for __ in range(int(input())):
n = int(input())
ar = list(map(int, input().split()))
ar.reverse()
print(*ar) | 3
2
1 2
6
2 1 6 5 4 3
5
2 4 3 1 5
| interview |
def HYDan():
"""Being tired of participating in too many Codeforces rounds, Gildong decided to take some rest in a park. He sat down on a bench, and soon he found two rabbits hopping around. One of the rabbits was taller than the other.
He noticed that the two rabbits were hopping towards each other. The positions of the two rabbits can be represented as integer coordinates on a horizontal line. The taller rabbit is currently on position $x$, and the shorter rabbit is currently on position $y$ ($x \lt y$). Every second, each rabbit hops to another position. The taller rabbit hops to the positive direction by $a$, and the shorter rabbit hops to the negative direction by $b$.
[Image]
For example, let's say $x=0$, $y=10$, $a=2$, and $b=3$. At the $1$-st second, each rabbit will be at position $2$ and $7$. At the $2$-nd second, both rabbits will be at position $4$.
Gildong is now wondering: Will the two rabbits be at the same position at the same moment? If so, how long will it take? Let's find a moment in time (in seconds) after which the rabbits will be at the same point.
-----Input-----
Each test contains one or more test cases. The first line contains the number of test cases $t$ ($1 \le t \le 1000$).
Each test case contains exactly one line. The line consists of four integers $x$, $y$, $a$, $b$ ($0 \le x \lt y \le 10^9$, $1 \le a,b \le 10^9$) β the current position of the taller rabbit, the current position of the shorter rabbit, the hopping distance of the taller rabbit, and the hopping distance of the shorter rabbit, respectively.
-----Output-----
For each test case, print the single integer: number of seconds the two rabbits will take to be at the same position.
If the two rabbits will never be at the same position simultaneously, print $-1$.
-----Example-----
Input
5
0 10 2 3
0 10 3 3
900000000 1000000000 1 9999999
1 2 1 1
1 3 1 1
Output
2
-1
10
-1
1
-----Note-----
The first case is explained in the description.
In the second case, each rabbit will be at position $3$ and $7$ respectively at the $1$-st second. But in the $2$-nd second they will be at $6$ and $4$ respectively, and we can see that they will never be at the same position since the distance between the two rabbits will only increase afterward.
"""
|
def HYDan():
def one():
return int(input())
def two():
return list(map(int, input().split()))
def lis():
return list(map(int, input().split()))
def st():
return input()
for _ in range(one()):
x, y, a, b = list(map(int, input().split()))
d = y - x
if d%(a+b)==0:
print(d//(a+b))
else:
print(-1)
| 5
0 10 2 3
0 10 3 3
900000000 1000000000 1 9999999
1 2 1 1
1 3 1 1
| interview |
def zirsm():
"""Let's look at the following process: initially you have an empty stack and an array $s$ of the length $l$. You are trying to push array elements to the stack in the order $s_1, s_2, s_3, \dots s_{l}$. Moreover, if the stack is empty or the element at the top of this stack is not equal to the current element, then you just push the current element to the top of the stack. Otherwise, you don't push the current element to the stack and, moreover, pop the top element of the stack.
If after this process the stack remains empty, the array $s$ is considered stack exterminable.
There are samples of stack exterminable arrays: $[1, 1]$; $[2, 1, 1, 2]$; $[1, 1, 2, 2]$; $[1, 3, 3, 1, 2, 2]$; $[3, 1, 3, 3, 1, 3]$; $[3, 3, 3, 3, 3, 3]$; $[5, 1, 2, 2, 1, 4, 4, 5]$;
Let's consider the changing of stack more details if $s = [5, 1, 2, 2, 1, 4, 4, 5]$ (the top of stack is highlighted). after pushing $s_1 = 5$ the stack turn into $[\textbf{5}]$; after pushing $s_2 = 1$ the stack turn into $[5, \textbf{1}]$; after pushing $s_3 = 2$ the stack turn into $[5, 1, \textbf{2}]$; after pushing $s_4 = 2$ the stack turn into $[5, \textbf{1}]$; after pushing $s_5 = 1$ the stack turn into $[\textbf{5}]$; after pushing $s_6 = 4$ the stack turn into $[5, \textbf{4}]$; after pushing $s_7 = 4$ the stack turn into $[\textbf{5}]$; after pushing $s_8 = 5$ the stack is empty.
You are given an array $a_1, a_2, \ldots, a_n$. You have to calculate the number of its subarrays which are stack exterminable.
Note, that you have to answer $q$ independent queries.
-----Input-----
The first line contains one integer $q$ ($1 \le q \le 3 \cdot 10^5$)Β β the number of queries.
The first line of each query contains one integer $n$ ($1 \le n \le 3 \cdot 10^5$)Β β the length of array $a$.
The second line of each query contains $n$ integers $a_1, a_2, \ldots, a_n$ ($1 \le a_i \le n$)Β β the elements.
It is guaranteed that the sum of all $n$ over all queries does not exceed $3 \cdot 10^5$.
-----Output-----
For each test case print one integer in single line β the number of stack exterminable subarrays of the array $a$.
-----Example-----
Input
3
5
2 1 1 2 2
6
1 2 1 1 3 2
9
3 1 2 2 1 6 6 3 3
Output
4
1
8
-----Note-----
In the first query there are four stack exterminable subarrays: $a_{1 \ldots 4} = [2, 1, 1, 2], a_{2 \ldots 3} = [1, 1], a_{2 \ldots 5} = [1, 1, 2, 2], a_{4 \ldots 5} = [2, 2]$.
In the second query, only one subarray is exterminable subarrayΒ β $a_{3 \ldots 4}$.
In the third query, there are eight stack exterminable subarrays: $a_{1 \ldots 8}, a_{2 \ldots 5}, a_{2 \ldots 7}, a_{2 \ldots 9}, a_{3 \ldots 4}, a_{6 \ldots 7}, a_{6 \ldots 9}, a_{8 \ldots 9}$.
"""
| from sys import stdin
def zirsm():
# encoding: utf-8
def solve(a):
# root node of tries denotes empty stack
stack = [None]
node_stack = [[1, {}]]
trie = node_stack[-1]
counter = 0
for i in range(len(a)):
el = a[i]
if len(stack) == 0 or stack[-1] != el:
current_node = node_stack[-1]
stack.append(el)
if el not in current_node[1]:
current_node[1][el] = [0, {}]
next_node = current_node[1][el]
next_node[0] += 1
node_stack.append(next_node)
else:
# just go up in trie
stack.pop()
node_stack.pop()
node_stack[-1][0] += 1
value = node_stack[-1][0]
counter -= (((value - 1) * (value - 2)) // 2)
counter += (((value) * (value - 1)) // 2)
return counter
q = int(stdin.readline().strip())
for _ in range(q):
n = int(stdin.readline().strip())
a = [int(i) for i in stdin.readline().strip().split()]
print(solve(a)) | 3
5
2 1 1 2 2
6
1 2 1 1 3 2
9
3 1 2 2 1 6 6 3 3
| interview |
def Lfvzj():
"""Consider the following process. You have a binary string (a string where each character is either 0 or 1) $w$ of length $n$ and an integer $x$. You build a new binary string $s$ consisting of $n$ characters. The $i$-th character of $s$ is chosen as follows:
if the character $w_{i-x}$ exists and is equal to 1, then $s_i$ is 1 (formally, if $i > x$ and $w_{i-x} = $ 1, then $s_i = $ 1); if the character $w_{i+x}$ exists and is equal to 1, then $s_i$ is 1 (formally, if $i + x \le n$ and $w_{i+x} = $ 1, then $s_i = $ 1); if both of the aforementioned conditions are false, then $s_i$ is 0.
You are given the integer $x$ and the resulting string $s$. Reconstruct the original string $w$.
-----Input-----
The first line contains one integer $t$ ($1 \le t \le 1000$) β the number of test cases.
Each test case consists of two lines. The first line contains the resulting string $s$ ($2 \le |s| \le 10^5$, each character of $s$ is either 0 or 1). The second line contains one integer $x$ ($1 \le x \le |s| - 1$).
The total length of all strings $s$ in the input does not exceed $10^5$.
-----Output-----
For each test case, print the answer on a separate line as follows:
if no string $w$ can produce the string $s$ at the end of the process, print $-1$; otherwise, print the binary string $w$ consisting of $|s|$ characters. If there are multiple answers, print any of them.
-----Example-----
Input
3
101110
2
01
1
110
1
Output
111011
10
-1
"""
| import sys
def Lfvzj():
input=sys.stdin.readline
for _ in range(int(input())):
s=input().rstrip()
x=int(input())
n=len(s)
ans=["1" for i in range(n)]
for i in range(n):
if s[i]=="0":
if i-x>=0:
ans[i-x]="0"
if i+x<n:
ans[i+x]="0"
for i in range(n):
if s[i]=="1":
check=False
if i-x>=0:
check|=(ans[i-x]=="1")
if i+x<n:
check|=(ans[i+x]=="1")
if not check:
print(-1)
break
else:
print("".join(ans)) | 3
101110
2
01
1
110
1
| interview |
def bImHP():
"""Berland year consists of $m$ months with $d$ days each. Months are numbered from $1$ to $m$. Berland week consists of $w$ days. The first day of the year is also the first day of the week. Note that the last week of the year might be shorter than $w$ days.
A pair $(x, y)$ such that $x < y$ is ambiguous if day $x$ of month $y$ is the same day of the week as day $y$ of month $x$.
Count the number of ambiguous pairs.
-----Input-----
The first line contains a single integer $t$ ($1 \le t \le 1000$)Β β the number of testcases.
Each of the next $t$ lines contains three integers $m$, $d$ and $w$ ($1 \le m, d, w \le 10^9$)Β β the number of months in a year, the number of days in a month and the number of days in a week.
-----Output-----
Print $t$ integersΒ β for each testcase output the number of pairs $(x, y)$ such that $x < y$ and day $x$ of month $y$ is the same day of the week as day $y$ of month $x$.
-----Example-----
Input
5
6 7 4
10 7 12
12 30 7
1 1 1
3247834 10298779 625324
Output
6
9
5
0
116461800
-----Note-----
Here are the pairs for the first test case: $$
"""
| import sys
def bImHP():
readline = sys.stdin.readline
readlines = sys.stdin.readlines
ns = lambda: readline().rstrip()
ni = lambda: int(readline().rstrip())
nm = lambda: map(int, readline().split())
nl = lambda: list(map(int, readline().split()))
prn = lambda x: print(*x, sep='\n')
def gcd(a, b):
while b:
a, b = b, a%b
return a
def solve():
m, d, w = nm()
g = w // gcd(d-1, w)
c = min(m, d)
v = c // g
ans = v * (v - 1) // 2 * g
ans += (c - g * v) * v
print(ans)
return
# solve()
T = ni()
for _ in range(T):
solve() | 5
6 7 4
10 7 12
12 30 7
1 1 1
3247834 10298779 625324
| interview |
def EUvVC():
"""Bob is playing with $6$-sided dice. A net of such standard cube is shown below.
[Image]
He has an unlimited supply of these dice and wants to build a tower by stacking multiple dice on top of each other, while choosing the orientation of each dice. Then he counts the number of visible pips on the faces of the dice.
For example, the number of visible pips on the tower below is $29$ β the number visible on the top is $1$, from the south $5$ and $3$, from the west $4$ and $2$, from the north $2$ and $4$ and from the east $3$ and $5$.
[Image]
The one at the bottom and the two sixes by which the dice are touching are not visible, so they are not counted towards total.
Bob also has $t$ favourite integers $x_i$, and for every such integer his goal is to build such a tower that the number of visible pips is exactly $x_i$. For each of Bob's favourite integers determine whether it is possible to build a tower that has exactly that many visible pips.
-----Input-----
The first line contains a single integer $t$ ($1 \leq t \leq 1000$)Β β the number of favourite integers of Bob.
The second line contains $t$ space-separated integers $x_i$ ($1 \leq x_i \leq 10^{18}$)Β β Bob's favourite integers.
-----Output-----
For each of Bob's favourite integers, output "YES" if it is possible to build the tower, or "NO" otherwise (quotes for clarity).
-----Example-----
Input
4
29 34 19 38
Output
YES
YES
YES
NO
-----Note-----
The first example is mentioned in the problem statement.
In the second example, one can build the tower by flipping the top dice from the previous tower.
In the third example, one can use a single die that has $5$ on top.
The fourth example is impossible.
"""
|
def EUvVC():
n = input()
a = list(map(int, input().split()))
for i in a:
if i % 7 == 0 or (i // 7) % 2 == 1 or i <= 14:
print('NO')
else:
print('YES') | 4
29 34 19 38
| interview |
def Rejcr():
"""Monocarp had a tree which consisted of $n$ vertices and was rooted at vertex $1$. He decided to study BFS (Breadth-first search), so he ran BFS on his tree, starting from the root. BFS can be described by the following pseudocode:a = [] # the order in which vertices were processed
q = Queue()
q.put(1) # place the root at the end of the queue
while not q.empty():
k = q.pop() # retrieve the first vertex from the queue
a.append(k) # append k to the end of the sequence in which vertices were visited
for y in g[k]: # g[k] is the list of all children of vertex k, sorted in ascending order
q.put(y)
Monocarp was fascinated by BFS so much that, in the end, he lost his tree. Fortunately, he still has a sequence of vertices, in which order vertices were visited by the BFS algorithm (the array a from the pseudocode). Monocarp knows that each vertex was visited exactly once (since they were put and taken from the queue exactly once). Also, he knows that all children of each vertex were viewed in ascending order.
Monocarp knows that there are many trees (in the general case) with the same visiting order $a$, so he doesn't hope to restore his tree. Monocarp is okay with any tree that has minimum height.
The height of a tree is the maximum depth of the tree's vertices, and the depth of a vertex is the number of edges in the path from the root to it. For example, the depth of vertex $1$ is $0$, since it's the root, and the depth of all root's children are $1$.
Help Monocarp to find any tree with given visiting order $a$ and minimum height.
-----Input-----
The first line contains a single integer $t$ ($1 \le t \le 1000$)Β β the number of test cases.
The first line of each test case contains a single integer $n$ ($2 \le n \le 2 \cdot 10^5$)Β β the number of vertices in the tree.
The second line of each test case contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \le a_i \le n$; $a_i \neq a_j$; $a_1 = 1$)Β β the order in which the vertices were visited by the BFS algorithm.
It's guaranteed that the total sum of $n$ over test cases doesn't exceed $2 \cdot 10^5$.
-----Output-----
For each test case print the minimum possible height of a tree with the given visiting order $a$.
-----Example-----
Input
3
4
1 4 3 2
2
1 2
3
1 2 3
Output
3
1
1
-----Note-----
In the first test case, there is only one tree with the given visiting order: [Image]
In the second test case, there is only one tree with the given visiting order as well: [Image]
In the third test case, an optimal tree with the given visiting order is shown below: [Image]
"""
| from sys import stdin
def Rejcr():
tt = int(stdin.readline())
for loop in range(tt):
n = int(stdin.readline())
a = list(map(int,stdin.readline().split()))
lis = [ [1] ]
now = []
tmp = 0
for i in range(1,n):
if len(now) == 0:
now.append(a[i])
tmp = 1
elif now[-1] > a[i]:
if tmp == len(lis[-1]):
lis.append(now)
now = [a[i]]
tmp = 1
else:
tmp += 1
now.append(a[i])
else:
now.append(a[i])
if len(now) > 0:
lis.append(now)
#print (lis)
print (len(lis)-1) | 3
4
1 4 3 2
2
1 2
3
1 2 3
| interview |
def fSOgC():
"""You are given an array $a$, consisting of $n$ integers.
Each position $i$ ($1 \le i \le n$) of the array is either locked or unlocked. You can take the values on the unlocked positions, rearrange them in any order and place them back into the unlocked positions. You are not allowed to remove any values, add the new ones or rearrange the values on the locked positions. You are allowed to leave the values in the same order as they were.
For example, let $a = [-1, 1, \underline{3}, 2, \underline{-2}, 1, -4, \underline{0}]$, the underlined positions are locked. You can obtain the following arrays: $[-1, 1, \underline{3}, 2, \underline{-2}, 1, -4, \underline{0}]$; $[-4, -1, \underline{3}, 2, \underline{-2}, 1, 1, \underline{0}]$; $[1, -1, \underline{3}, 2, \underline{-2}, 1, -4, \underline{0}]$; $[1, 2, \underline{3}, -1, \underline{-2}, -4, 1, \underline{0}]$; and some others.
Let $p$ be a sequence of prefix sums of the array $a$ after the rearrangement. So $p_1 = a_1$, $p_2 = a_1 + a_2$, $p_3 = a_1 + a_2 + a_3$, $\dots$, $p_n = a_1 + a_2 + \dots + a_n$.
Let $k$ be the maximum $j$ ($1 \le j \le n$) such that $p_j < 0$. If there are no $j$ such that $p_j < 0$, then $k = 0$.
Your goal is to rearrange the values in such a way that $k$ is minimum possible.
Output the array $a$ after the rearrangement such that the value $k$ for it is minimum possible. If there are multiple answers then print any of them.
-----Input-----
The first line contains a single integer $t$ ($1 \le t \le 1000$)Β β the number of testcases.
Then $t$ testcases follow.
The first line of each testcase contains a single integer $n$ ($1 \le n \le 100$)Β β the number of elements in the array $a$.
The second line of each testcase contains $n$ integers $a_1, a_2, \dots, a_n$ ($-10^5 \le a_i \le 10^5$)Β β the initial array $a$.
The third line of each testcase contains $n$ integers $l_1, l_2, \dots, l_n$ ($0 \le l_i \le 1$), where $l_i = 0$ means that the position $i$ is unlocked and $l_i = 1$ means that the position $i$ is locked.
-----Output-----
Print $n$ integersΒ β the array $a$ after the rearrangement. Value $k$ (the maximum $j$ such that $p_j < 0$ (or $0$ if there are no such $j$)) should be minimum possible. For each locked position the printed value should be equal to the initial one. The values on the unlocked positions should be an arrangement of the initial ones.
If there are multiple answers then print any of them.
-----Example-----
Input
5
3
1 3 2
0 0 0
4
2 -3 4 -1
1 1 1 1
7
-8 4 -2 -6 4 7 1
1 0 0 0 1 1 0
5
0 1 -4 6 3
0 0 0 1 1
6
-1 7 10 4 -8 -1
1 0 0 0 0 1
Output
1 2 3
2 -3 4 -1
-8 -6 1 4 4 7 -2
-4 0 1 6 3
-1 4 7 -8 10 -1
-----Note-----
In the first testcase you can rearrange all values however you want but any arrangement will result in $k = 0$. For example, for an arrangement $[1, 2, 3]$, $p=[1, 3, 6]$, so there are no $j$ such that $p_j < 0$. Thus, $k = 0$.
In the second testcase you are not allowed to rearrange any elements. Thus, the printed array should be exactly the same as the initial one.
In the third testcase the prefix sums for the printed array are $p = [-8, -14, -13, -9, -5, 2, 0]$. The maximum $j$ is $5$, thus $k = 5$. There are no arrangements such that $k < 5$.
In the fourth testcase $p = [-4, -4, -3, 3, 6]$.
In the fifth testcase $p = [-1, 3, 10, 2, 12, 11]$.
"""
| import math
from collections import deque
from sys import stdin, stdout
from string import ascii_letters
import sys
def fSOgC():
letters = ascii_letters
input = stdin.readline
#print = stdout.write
for _ in range(int(input())):
n = int(input())
arr = list(map(int, input().split()))
can = list(map(int, input().split()))
vals = sorted([i for i in range(n) if not can[i]], key=lambda x: -arr[x])
res = [0] * n
last = 0
for i in range(n):
if can[i]:
res[i] = arr[i]
else:
res[i] = arr[vals[last]]
last += 1
print(*res) | 5
3
1 3 2
0 0 0
4
2 -3 4 -1
1 1 1 1
7
-8 4 -2 -6 4 7 1
1 0 0 0 1 1 0
5
0 1 -4 6 3
0 0 0 1 1
6
-1 7 10 4 -8 -1
1 0 0 0 0 1
| interview |
def DjPrt():
"""Permutation $p$ is a sequence of integers $p=[p_1, p_2, \dots, p_n]$, consisting of $n$ distinct (unique) positive integers between $1$ and $n$, inclusive. For example, the following sequences are permutations: $[3, 4, 1, 2]$, $[1]$, $[1, 2]$. The following sequences are not permutations: $[0]$, $[1, 2, 1]$, $[2, 3]$, $[0, 1, 2]$.
The important key is in the locked box that you need to open. To open the box you need to enter secret code. Secret code is a permutation $p$ of length $n$.
You don't know this permutation, you only know the array $q$ of prefix maximums of this permutation. Formally: $q_1=p_1$, $q_2=\max(p_1, p_2)$, $q_3=\max(p_1, p_2,p_3)$, ... $q_n=\max(p_1, p_2,\dots,p_n)$.
You want to construct any possible suitable permutation (i.e. any such permutation, that calculated $q$ for this permutation is equal to the given array).
-----Input-----
The first line contains integer number $t$ ($1 \le t \le 10^4$)Β β the number of test cases in the input. Then $t$ test cases follow.
The first line of a test case contains one integer $n$ $(1 \le n \le 10^{5})$Β β the number of elements in the secret code permutation $p$.
The second line of a test case contains $n$ integers $q_1, q_2, \dots, q_n$ $(1 \le q_i \le n)$Β β elements of the array $q$ for secret permutation. It is guaranteed that $q_i \le q_{i+1}$ for all $i$ ($1 \le i < n$).
The sum of all values $n$ over all the test cases in the input doesn't exceed $10^5$.
-----Output-----
For each test case, print: If it's impossible to find such a permutation $p$, print "-1" (without quotes). Otherwise, print $n$ distinct integers $p_1, p_2, \dots, p_n$ ($1 \le p_i \le n$). If there are multiple possible answers, you can print any of them.
-----Example-----
Input
4
5
1 3 4 5 5
4
1 1 3 4
2
2 2
1
1
Output
1 3 4 5 2
-1
2 1
1
-----Note-----
In the first test case of the example answer $[1,3,4,5,2]$ is the only possible answer: $q_{1} = p_{1} = 1$; $q_{2} = \max(p_{1}, p_{2}) = 3$; $q_{3} = \max(p_{1}, p_{2}, p_{3}) = 4$; $q_{4} = \max(p_{1}, p_{2}, p_{3}, p_{4}) = 5$; $q_{5} = \max(p_{1}, p_{2}, p_{3}, p_{4}, p_{5}) = 5$.
It can be proved that there are no answers for the second test case of the example.
"""
|
def DjPrt():
t = int(input())
for faw in range(t):
n = int(input())
a = [0] + list(map(int,input().split()))
nun = []
ans = []
f = True
for i in range(1, n + 1):
if a[i] == a[i-1]:
if len(nun) == 0:
f = False
break
else:
ans.append(nun.pop())
else:
ans.append(a[i])
for i in range(a[i - 1] + 1, a[i]):
nun.append(i)
if f:
print(*ans)
else:
print(-1)
| 4
5
1 3 4 5 5
4
1 1 3 4
2
2 2
1
1
| interview |
def SKGHC():
"""You are given two strings of equal length $s$ and $t$ consisting of lowercase Latin letters. You may perform any number (possibly, zero) operations on these strings.
During each operation you choose two adjacent characters in any string and assign the value of the first character to the value of the second or vice versa.
For example, if $s$ is "acbc" you can get the following strings in one operation: "aabc" (if you perform $s_2 = s_1$); "ccbc" (if you perform $s_1 = s_2$); "accc" (if you perform $s_3 = s_2$ or $s_3 = s_4$); "abbc" (if you perform $s_2 = s_3$); "acbb" (if you perform $s_4 = s_3$);
Note that you can also apply this operation to the string $t$.
Please determine whether it is possible to transform $s$ into $t$, applying the operation above any number of times.
Note that you have to answer $q$ independent queries.
-----Input-----
The first line contains one integer $q$ ($1 \le q \le 100$)Β β the number of queries. Each query is represented by two consecutive lines.
The first line of each query contains the string $s$ ($1 \le |s| \le 100$) consisting of lowercase Latin letters.
The second line of each query contains the string $t$ ($1 \le |t| \leq 100$, $|t| = |s|$) consisting of lowercase Latin letters.
-----Output-----
For each query, print "YES" if it is possible to make $s$ equal to $t$, and "NO" 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 answer).
-----Example-----
Input
3
xabb
aabx
technocup
technocup
a
z
Output
YES
YES
NO
-----Note-----
In the first query, you can perform two operations $s_1 = s_2$ (after it $s$ turns into "aabb") and $t_4 = t_3$ (after it $t$ turns into "aabb").
In the second query, the strings are equal initially, so the answer is "YES".
In the third query, you can not make strings $s$ and $t$ equal. Therefore, the answer is "NO".
"""
|
def SKGHC():
for _ in range(int(input())):
print("YES" if set(input()).intersection(input()) else "NO")
| 3
xabb
aabx
technocup
technocup
a
z
| interview |
def nlegK():
"""Santa has to send presents to the kids. He has a large stack of $n$ presents, numbered from $1$ to $n$; the topmost present has number $a_1$, the next present is $a_2$, and so on; the bottom present has number $a_n$. All numbers are distinct.
Santa has a list of $m$ distinct presents he has to send: $b_1$, $b_2$, ..., $b_m$. He will send them in the order they appear in the list.
To send a present, Santa has to find it in the stack by removing all presents above it, taking this present and returning all removed presents on top of the stack. So, if there are $k$ presents above the present Santa wants to send, it takes him $2k + 1$ seconds to do it. Fortunately, Santa can speed the whole process up β when he returns the presents to the stack, he may reorder them as he wishes (only those which were above the present he wanted to take; the presents below cannot be affected in any way).
What is the minimum time required to send all of the presents, provided that Santa knows the whole list of presents he has to send and reorders the presents optimally? Santa cannot change the order of presents or interact with the stack of presents in any other way.
Your program has to answer $t$ different test cases.
-----Input-----
The first line contains one integer $t$ ($1 \le t \le 100$) β the number of test cases.
Then the test cases follow, each represented by three lines.
The first line contains two integers $n$ and $m$ ($1 \le m \le n \le 10^5$) β the number of presents in the stack and the number of presents Santa wants to send, respectively.
The second line contains $n$ integers $a_1$, $a_2$, ..., $a_n$ ($1 \le a_i \le n$, all $a_i$ are unique) β the order of presents in the stack.
The third line contains $m$ integers $b_1$, $b_2$, ..., $b_m$ ($1 \le b_i \le n$, all $b_i$ are unique) β the ordered list of presents Santa has to send.
The sum of $n$ over all test cases does not exceed $10^5$.
-----Output-----
For each test case print one integer β the minimum number of seconds which Santa has to spend sending presents, if he reorders the presents optimally each time he returns them into the stack.
-----Example-----
Input
2
3 3
3 1 2
3 2 1
7 2
2 1 7 3 4 5 6
3 1
Output
5
8
"""
|
def nlegK():
for tc in range(int(input())):
n,m = list(map(int, input().split()))
al = list(map(int, input().split()))
bl = list(map(int, input().split()))
aidx = {}
for i,e in enumerate(al):
aidx[e]=i
midx = -1
res = 0
for i,e in enumerate(bl):
idx = aidx[e]
if idx <= midx:
res += 1
else:
res += 2*(idx-i)+1
midx = max(midx, idx)
print(res)
| 2
3 3
3 1 2
3 2 1
7 2
2 1 7 3 4 5 6
3 1
| interview |
def QwRSB():
"""Petya has come to the math exam and wants to solve as many problems as possible. He prepared and carefully studied the rules by which the exam passes.
The exam consists of $n$ problems that can be solved in $T$ minutes. Thus, the exam begins at time $0$ and ends at time $T$. Petya can leave the exam at any integer time from $0$ to $T$, inclusive.
All problems are divided into two types: easy problems β Petya takes exactly $a$ minutes to solve any easy problem; hard problems β Petya takes exactly $b$ minutes ($b > a$) to solve any hard problem.
Thus, if Petya starts solving an easy problem at time $x$, then it will be solved at time $x+a$. Similarly, if at a time $x$ Petya starts to solve a hard problem, then it will be solved at time $x+b$.
For every problem, Petya knows if it is easy or hard. Also, for each problem is determined time $t_i$ ($0 \le t_i \le T$) at which it will become mandatory (required). If Petya leaves the exam at time $s$ and there is such a problem $i$ that $t_i \le s$ and he didn't solve it, then he will receive $0$ points for the whole exam. Otherwise (i.e if he has solved all such problems for which $t_i \le s$) he will receive a number of points equal to the number of solved problems. Note that leaving at time $s$ Petya can have both "mandatory" and "non-mandatory" problems solved.
For example, if $n=2$, $T=5$, $a=2$, $b=3$, the first problem is hard and $t_1=3$ and the second problem is easy and $t_2=2$. Then: if he leaves at time $s=0$, then he will receive $0$ points since he will not have time to solve any problems; if he leaves at time $s=1$, he will receive $0$ points since he will not have time to solve any problems; if he leaves at time $s=2$, then he can get a $1$ point by solving the problem with the number $2$ (it must be solved in the range from $0$ to $2$); if he leaves at time $s=3$, then he will receive $0$ points since at this moment both problems will be mandatory, but he will not be able to solve both of them; if he leaves at time $s=4$, then he will receive $0$ points since at this moment both problems will be mandatory, but he will not be able to solve both of them; if he leaves at time $s=5$, then he can get $2$ points by solving all problems.
Thus, the answer to this test is $2$.
Help Petya to determine the maximal number of points that he can receive, before leaving the exam.
-----Input-----
The first line contains the integer $m$ ($1 \le m \le 10^4$)Β β the number of test cases in the test.
The next lines contain a description of $m$ test cases.
The first line of each test case contains four integers $n, T, a, b$ ($2 \le n \le 2\cdot10^5$, $1 \le T \le 10^9$, $1 \le a < b \le 10^9$)Β β the number of problems, minutes given for the exam and the time to solve an easy and hard problem, respectively.
The second line of each test case contains $n$ numbers $0$ or $1$, separated by single space: the $i$-th number means the type of the $i$-th problem. A value of $0$ means that the problem is easy, and a value of $1$ that the problem is hard.
The third line of each test case contains $n$ integers $t_i$ ($0 \le t_i \le T$), where the $i$-th number means the time at which the $i$-th problem will become mandatory.
It is guaranteed that the sum of $n$ for all test cases does not exceed $2\cdot10^5$.
-----Output-----
Print the answers to $m$ test cases. For each set, print a single integerΒ β maximal number of points that he can receive, before leaving the exam.
-----Example-----
Input
10
3 5 1 3
0 0 1
2 1 4
2 5 2 3
1 0
3 2
1 20 2 4
0
16
6 20 2 5
1 1 0 1 0 0
0 8 2 9 11 6
4 16 3 6
1 0 1 1
8 3 5 6
6 20 3 6
0 1 0 0 1 0
20 11 3 20 16 17
7 17 1 6
1 1 0 1 0 0 0
1 7 0 11 10 15 10
6 17 2 6
0 0 1 0 0 1
7 6 3 7 10 12
5 17 2 5
1 1 1 1 0
17 11 10 6 4
1 1 1 2
0
1
Output
3
2
1
0
1
4
0
1
2
1
"""
| import sys
from operator import itemgetter
def QwRSB():
def count(a, b, num_a, num_b, cur_time):
current_result = 0
#print('count time = ', cur_time, "num_a =", num_a, 'num_b = ', num_b)
if num_a * a + num_b * b <= cur_time and cur_time >= 0:
cur_time -= num_a * a + num_b * b
current_result = num_a + num_b
if num_a < total_a:
if (total_a - num_a) * a <= cur_time:
current_result += total_a - num_a
cur_time -= (total_a - num_a) * a
#print(1)
else:
current_result += cur_time // a
cur_time -= a *(cur_time // a)
#print(2)
if num_b < total_b:
if (total_b - num_b) * b <= cur_time:
current_result += total_b - num_b
#print(3)
else:
#print(4)
current_result += cur_time // b
#print('current_result = ', current_result)
return current_result
def solve(n, T, a, b, tasks, total_a, total_b):
tasks = sorted(tasks)
#print(tasks)
result = 0
num_a = 0
num_b = 0
for i in range(len(tasks)):
time, t = tasks[i]
#print(tasks[i])
cur_time = time - 1
#print('cur time = ', cur_time)
current_result = count(a, b, num_a, num_b, cur_time)
result = max(current_result, result)
if t == 0:
num_a += 1
else:
num_b += 1
if i == len(tasks) - 1 or tasks[i + 1][1] != tasks[i][1]:
result = max(result, count(a, b, num_a, num_b, cur_time))
#print("i =", i, "result = ", result)
result = max(result, count(a, b, total_a, total_b, T))
return result
q = int(input())
for i in range(q):
n, T, a, b = list(map(int, input().split()))
types = list(map(int, input().split()))
total_a, total_b = 0, 0
for t in types:
if t == 0:
total_a += 1
else:
total_b += 1
t = list(map(int, input().split()))
#print(t)
#print(types)
tasks = list(zip(t, types))
print(solve(n, T, a, b, tasks, total_a, total_b)) | 10
3 5 1 3
0 0 1
2 1 4
2 5 2 3
1 0
3 2
1 20 2 4
0
16
6 20 2 5
1 1 0 1 0 0
0 8 2 9 11 6
4 16 3 6
1 0 1 1
8 3 5 6
6 20 3 6
0 1 0 0 1 0
20 11 3 20 16 17
7 17 1 6
1 1 0 1 0 0 0
1 7 0 11 10 15 10
6 17 2 6
0 0 1 0 0 1
7 6 3 7 10 12
5 17 2 5
1 1 1 1 0
17 11 10 6 4
1 1 1 2
0
1
| interview |
def IlZDc():
"""Your friend Jeff Zebos has been trying to run his new online company, but it's not going very well. He's not getting a lot of sales on his website which he decided to call Azamon. His big problem, you think, is that he's not ranking high enough on the search engines. If only he could rename his products to have better names than his competitors, then he'll be at the top of the search results and will be a millionaire.
After doing some research, you find out that search engines only sort their results lexicographically. If your friend could rename his products to lexicographically smaller strings than his competitor's, then he'll be at the top of the rankings!
To make your strategy less obvious to his competitors, you decide to swap no more than two letters of the product names.
Please help Jeff to find improved names for his products that are lexicographically smaller than his competitor's!
Given the string $s$ representing Jeff's product name and the string $c$ representing his competitor's product name, find a way to swap at most one pair of characters in $s$ (that is, find two distinct indices $i$ and $j$ and swap $s_i$ and $s_j$) such that the resulting new name becomes strictly lexicographically smaller than $c$, or determine that it is impossible.
Note: String $a$ is strictly lexicographically smaller than string $b$ if and only if one of the following holds: $a$ is a proper prefix of $b$, that is, $a$ is a prefix of $b$ such that $a \neq b$; There exists an integer $1 \le i \le \min{(|a|, |b|)}$ such that $a_i < b_i$ and $a_j = b_j$ for $1 \le j < i$.
-----Input-----
The first line of input contains a single integer $t$ ($1 \le t \le 1500$) denoting the number of test cases. The next lines contain descriptions of the test cases.
Each test case consists of a single line containing two space-separated strings $s$ and $c$ ($2 \le |s| \le 5000, 1 \le |c| \le 5000$). The strings $s$ and $c$ consists of uppercase English letters.
It is guaranteed that the sum of $|s|$ in the input is at most $5000$ and the sum of the $|c|$ in the input is at most $5000$.
-----Output-----
For each test case, output a single line containing a single string, which is either the new name which is obtained after swapping no more than one pair of characters that is strictly lexicographically smaller than $c$. In case there are many possible such strings, you can output any of them; three dashes (the string "---" without quotes) if it is impossible.
-----Example-----
Input
3
AZAMON APPLE
AZAMON AAAAAAAAAAALIBABA
APPLE BANANA
Output
AMAZON
---
APPLE
-----Note-----
In the first test case, it is possible to swap the second and the fourth letters of the string and the resulting string "AMAZON" is lexicographically smaller than "APPLE".
It is impossible to improve the product's name in the second test case and satisfy all conditions.
In the third test case, it is possible not to swap a pair of characters. The name "APPLE" is lexicographically smaller than "BANANA". Note that there are other valid answers, e.g., "APPEL".
"""
| import sys
def IlZDc():
reader = (s.rstrip() for s in sys.stdin)
input = reader.__next__
def solve():
s,c = input().split()
# i,jγ§jγθ€ζ°γγγ¨γ
n = len(s)
for i in range(n-1):
prev = s[i]
pos = i
for j in range(i+1, n):
if s[j]<prev:
prev = s[j]
pos = j
elif s[j] == prev:
pos = j
if prev == s[i]:
continue
t = list(s)
t[i], t[pos] = prev, s[i]
s = "".join(t)
break
if s<c:
print(s)
else:
print("---")
t = int(input())
for i in range(t):
solve() | 3
AZAMON APPLE
AZAMON AAAAAAAAAAALIBABA
APPLE BANANA
| interview |
def CmWIA():
"""You may have already known that a standard ICPC team consists of exactly three members. The perfect team however has more restrictions. A student can have some specialization: coder or mathematician. She/he can have no specialization, but can't have both at the same time.
So the team is considered perfect if it includes at least one coder, at least one mathematician and it consists of exactly three members.
You are a coach at a very large university and you know that $c$ of your students are coders, $m$ are mathematicians and $x$ have no specialization.
What is the maximum number of full perfect teams you can distribute them into?
Note that some students can be left without a team and each student can be a part of no more than one team.
You are also asked to answer $q$ independent queries.
-----Input-----
The first line contains a single integer $q$ ($1 \le q \le 10^4$) β the number of queries.
Each of the next $q$ lines contains three integers $c$, $m$ and $x$ ($0 \le c, m, x \le 10^8$) β the number of coders, mathematicians and students without any specialization in the university, respectively.
Note that the no student is both coder and mathematician at the same time.
-----Output-----
Print $q$ integers β the $i$-th of them should be the answer to the $i$ query in the order they are given in the input. The answer is the maximum number of full perfect teams you can distribute your students into.
-----Example-----
Input
6
1 1 1
3 6 0
0 0 0
0 1 1
10 1 10
4 4 1
Output
1
3
0
0
1
3
-----Note-----
In the first example here are how teams are formed: the only team of 1 coder, 1 mathematician and 1 without specialization; all three teams consist of 1 coder and 2 mathematicians; no teams can be formed; no teams can be formed; one team consists of 1 coder, 1 mathematician and 1 without specialization, the rest aren't able to form any team; one team consists of 1 coder, 1 mathematician and 1 without specialization, one consists of 2 coders and 1 mathematician and one consists of 1 coder and 2 mathematicians.
"""
|
def CmWIA():
q = int(input())
for _ in range(q):
c, m, x = list(map(int, input().split()))
print(min([c, m, (c + m + x) // 3])) | 6
1 1 1
3 6 0
0 0 0
0 1 1
10 1 10
4 4 1
| interview |
def bIBgE():
"""Lee was cleaning his house for the party when he found a messy string under the carpets. Now he'd like to make it clean accurately and in a stylish way...
The string $s$ he found is a binary string of length $n$ (i. e. string consists only of 0-s and 1-s).
In one move he can choose two consecutive characters $s_i$ and $s_{i+1}$, and if $s_i$ is 1 and $s_{i + 1}$ is 0, he can erase exactly one of them (he can choose which one to erase but he can't erase both characters simultaneously). The string shrinks after erasing.
Lee can make an arbitrary number of moves (possibly zero) and he'd like to make the string $s$ as clean as possible. He thinks for two different strings $x$ and $y$, the shorter string is cleaner, and if they are the same length, then the lexicographically smaller string is cleaner.
Now you should answer $t$ test cases: for the $i$-th test case, print the cleanest possible string that Lee can get by doing some number of moves.
Small reminder: if we have two strings $x$ and $y$ of the same length then $x$ is lexicographically smaller than $y$ if there is a position $i$ such that $x_1 = y_1$, $x_2 = y_2$,..., $x_{i - 1} = y_{i - 1}$ and $x_i < y_i$.
-----Input-----
The first line contains the integer $t$ ($1 \le t \le 10^4$)Β β the number of test cases.
Next $2t$ lines contain test casesΒ β one per two lines.
The first line of each test case contains the integer $n$ ($1 \le n \le 10^5$)Β β the length of the string $s$.
The second line contains the binary string $s$. The string $s$ is a string of length $n$ which consists only of zeroes and ones.
It's guaranteed that sum of $n$ over test cases doesn't exceed $10^5$.
-----Output-----
Print $t$ answersΒ β one per test case.
The answer to the $i$-th test case is the cleanest string Lee can get after doing some number of moves (possibly zero).
-----Example-----
Input
5
10
0001111111
4
0101
8
11001101
10
1110000000
1
1
Output
0001111111
001
01
0
1
-----Note-----
In the first test case, Lee can't perform any moves.
In the second test case, Lee should erase $s_2$.
In the third test case, Lee can make moves, for example, in the following order: 11001101Β $\rightarrow$ 1100101Β $\rightarrow$ 110101Β $\rightarrow$ 10101Β $\rightarrow$ 1101Β $\rightarrow$ 101Β $\rightarrow$ 01.
"""
|
def bIBgE():
for _ in range(int(input())):
# a, b = map(int, input().split())
n = int(input())
# arr = list(map(int, input().split()))
s = input()
l = 0
r = n - 1
if s.count('0') == n:
print(s)
continue
if s.count('1') == n:
print(s)
continue
while s[l] == '0':
l += 1
while s[r] == '1':
r -= 1
if r <= l:
print(s)
continue
print(l * '0' + '0' + (n - r - 1) * '1') | 5
10
0001111111
4
0101
8
11001101
10
1110000000
1
1
| interview |
def bVMjQ():
"""You have three piles of candies: red, green and blue candies: the first pile contains only red candies and there are $r$ candies in it, the second pile contains only green candies and there are $g$ candies in it, the third pile contains only blue candies and there are $b$ candies in it.
Each day Tanya eats exactly two candies of different colors. She is free to choose the colors of eaten candies: the only restriction that she can't eat two candies of the same color in a day.
Find the maximal number of days Tanya can eat candies? Each day she needs to eat exactly two candies.
-----Input-----
The first line contains integer $t$ ($1 \le t \le 1000$) β the number of test cases in the input. Then $t$ test cases follow.
Each test case is given as a separate line of the input. It contains three integers $r$, $g$ and $b$ ($1 \le r, g, b \le 10^8$) β the number of red, green and blue candies, respectively.
-----Output-----
Print $t$ integers: the $i$-th printed integer is the answer on the $i$-th test case in the input.
-----Example-----
Input
6
1 1 1
1 2 1
4 1 1
7 4 10
8 1 4
8 2 8
Output
1
2
2
10
5
9
-----Note-----
In the first example, Tanya can eat candies for one day only. She can eat any pair of candies this day because all of them have different colors.
In the second example, Tanya can eat candies for two days. For example, she can eat red and green candies on the first day, and green and blue candies on the second day.
In the third example, Tanya can eat candies for two days. For example, she can eat red and green candies on the first day, and red and blue candies on the second day. Note, that two red candies will remain uneaten.
"""
|
def bVMjQ():
n = int(input())
for _ in range(n):
a, b, c = list(map(int, input().split()))
print(min((a+b+c)//2, a+b, a+c, b+c))
| 6
1 1 1
1 2 1
4 1 1
7 4 10
8 1 4
8 2 8
| interview |
def rACVY():
"""Polycarp lives on the coordinate axis $Ox$ and travels from the point $x=a$ to $x=b$. It moves uniformly rectilinearly at a speed of one unit of distance per minute.
On the axis $Ox$ at the point $x=c$ the base station of the mobile operator is placed. It is known that the radius of its coverage is $r$. Thus, if Polycarp is at a distance less than or equal to $r$ from the point $x=c$, then he is in the network coverage area, otherwiseΒ β no. The base station can be located both on the route of Polycarp and outside it.
Print the time in minutes during which Polycarp will not be in the coverage area of the network, with a rectilinear uniform movement from $x=a$ to $x=b$. His speedΒ β one unit of distance per minute.
-----Input-----
The first line contains a positive integer $t$ ($1 \le t \le 1000$)Β β the number of test cases. In the following lines are written $t$ test cases.
The description of each test case is one line, which contains four integers $a$, $b$, $c$ and $r$ ($-10^8 \le a,b,c \le 10^8$, $0 \le r \le 10^8$)Β β the coordinates of the starting and ending points of the path, the base station, and its coverage radius, respectively.
Any of the numbers $a$, $b$ and $c$ can be equal (either any pair or all three numbers). The base station can be located both on the route of Polycarp and outside it.
-----Output-----
Print $t$ numbersΒ β answers to given test cases in the order they are written in the test. Each answer is an integerΒ β the number of minutes during which Polycarp will be unavailable during his movement.
-----Example-----
Input
9
1 10 7 1
3 3 3 0
8 2 10 4
8 2 10 100
-10 20 -17 2
-3 2 2 0
-3 1 2 0
2 3 2 3
-1 3 -2 2
Output
7
0
4
0
30
5
4
0
3
-----Note-----
The following picture illustrates the first test case. [Image] Polycarp goes from $1$ to $10$. The yellow area shows the coverage area of the station with a radius of coverage of $1$, which is located at the point of $7$. The green area shows a part of the path when Polycarp is out of coverage area.
"""
| import os
from io import BytesIO
def rACVY():
# input = BytesIO(os.read(0, os.fstat(0).st_size)).readline
for i in range(int(input())):
a, b, c, r = list(map(int, input().split()))
a, b = min(a, b), max(a, b)
left = max(c - r, a)
right = min(c + r, b)
if right >= a and left <= right:
print(b - a - (right - left))
else:
print(b - a) | 9
1 10 7 1
3 3 3 0
8 2 10 4
8 2 10 100
-10 20 -17 2
-3 2 2 0
-3 1 2 0
2 3 2 3
-1 3 -2 2
| interview |
def ioVNG():
"""Hooray! Polycarp turned $n$ years old! The Technocup Team sincerely congratulates Polycarp!
Polycarp celebrated all of his $n$ birthdays: from the $1$-th to the $n$-th. At the moment, he is wondering: how many times he turned beautiful number of years?
According to Polycarp, a positive integer is beautiful if it consists of only one digit repeated one or more times. For example, the following numbers are beautiful: $1$, $77$, $777$, $44$ and $999999$. The following numbers are not beautiful: $12$, $11110$, $6969$ and $987654321$.
Of course, Polycarpus uses the decimal numeral system (i.e. radix is 10).
Help Polycarpus to find the number of numbers from $1$ to $n$ (inclusive) that are beautiful.
-----Input-----
The first line contains an integer $t$ ($1 \le t \le 10^4$) β the number of test cases in the input. Then $t$ test cases follow.
Each test case consists of one line, which contains a positive integer $n$ ($1 \le n \le 10^9$) β how many years Polycarp has turned.
-----Output-----
Print $t$ integers β the answers to the given test cases in the order they are written in the test. Each answer is an integer: the number of beautiful years between $1$ and $n$, inclusive.
-----Example-----
Input
6
18
1
9
100500
33
1000000000
Output
10
1
9
45
12
81
-----Note-----
In the first test case of the example beautiful years are $1$, $2$, $3$, $4$, $5$, $6$, $7$, $8$, $9$ and $11$.
"""
|
def ioVNG():
s = []
for i in range(1, 10):
k = 0
for l in range(1, 10):
k *= 10
k += i
s.append(k)
s.sort()
q = int(input())
while q:
n = int(input())
l = 0
r = len(s)
while l + 1 < r:
m = (l + r) // 2
if s[m] <= n:
l = m
else:
r = m
print(r)
q -= 1 | 6
18
1
9
100500
33
1000000000
| interview |
def bzOnC():
"""Ashish and Vivek play a game on a matrix consisting of $n$ rows and $m$ columns, where they take turns claiming cells. Unclaimed cells are represented by $0$, while claimed cells are represented by $1$. The initial state of the matrix is given. There can be some claimed cells in the initial state.
In each turn, a player must claim a cell. A cell may be claimed if it is unclaimed and does not share a row or column with any other already claimed cells. When a player is unable to make a move, he loses and the game ends.
If Ashish and Vivek take turns to move and Ashish goes first, determine the winner of the game if both of them are playing optimally.
Optimal play between two players means that both players choose the best possible strategy to achieve the best possible outcome for themselves.
-----Input-----
The first line consists of a single integer $t$ $(1 \le t \le 50)$Β β the number of test cases. The description of the test cases follows.
The first line of each test case consists of two space-separated integers $n$, $m$ $(1 \le n, m \le 50)$Β β the number of rows and columns in the matrix.
The following $n$ lines consist of $m$ integers each, the $j$-th integer on the $i$-th line denoting $a_{i,j}$ $(a_{i,j} \in \{0, 1\})$.
-----Output-----
For each test case if Ashish wins the game print "Ashish" otherwise print "Vivek" (without quotes).
-----Example-----
Input
4
2 2
0 0
0 0
2 2
0 0
0 1
2 3
1 0 1
1 1 0
3 3
1 0 0
0 0 0
1 0 0
Output
Vivek
Ashish
Vivek
Ashish
-----Note-----
For the first case: One possible scenario could be: Ashish claims cell $(1, 1)$, Vivek then claims cell $(2, 2)$. Ashish can neither claim cell $(1, 2)$, nor cell $(2, 1)$ as cells $(1, 1)$ and $(2, 2)$ are already claimed. Thus Ashish loses. It can be shown that no matter what Ashish plays in this case, Vivek will win.
For the second case: Ashish claims cell $(1, 1)$, the only cell that can be claimed in the first move. After that Vivek has no moves left.
For the third case: Ashish cannot make a move, so Vivek wins.
For the fourth case: If Ashish claims cell $(2, 3)$, Vivek will have no moves left.
"""
|
def bzOnC():
t = int(input())
for _ in range(t):
n, m = [int(x) for x in input().split()]
grid = [[int(x) for x in input().split()] for _ in range(n)]
rows = sum(1 for x in grid if all(y == 0 for y in x))
cols = sum(1 for j in range(m) if all(grid[i][j] == 0 for i in range(n)))
res = min(rows, cols)
print("Ashish" if res % 2 else "Vivek")
| 4
2 2
0 0
0 0
2 2
0 0
0 1
2 3
1 0 1
1 1 0
3 3
1 0 0
0 0 0
1 0 0
| interview |
def atiSl():
"""You are given a colored permutation $p_1, p_2, \dots, p_n$. The $i$-th element of the permutation has color $c_i$.
Let's define an infinite path as infinite sequence $i, p[i], p[p[i]], p[p[p[i]]] \dots$ where all elements have same color ($c[i] = c[p[i]] = c[p[p[i]]] = \dots$).
We can also define a multiplication of permutations $a$ and $b$ as permutation $c = a \times b$ where $c[i] = b[a[i]]$. Moreover, we can define a power $k$ of permutation $p$ as $p^k=\underbrace{p \times p \times \dots \times p}_{k \text{ times}}$.
Find the minimum $k > 0$ such that $p^k$ has at least one infinite path (i.e. there is a position $i$ in $p^k$ such that the sequence starting from $i$ is an infinite path).
It can be proved that the answer always exists.
-----Input-----
The first line contains single integer $T$ ($1 \le T \le 10^4$) β the number of test cases.
Next $3T$ lines contain test cases β one per three lines. The first line contains single integer $n$ ($1 \le n \le 2 \cdot 10^5$) β the size of the permutation.
The second line contains $n$ integers $p_1, p_2, \dots, p_n$ ($1 \le p_i \le n$, $p_i \neq p_j$ for $i \neq j$) β the permutation $p$.
The third line contains $n$ integers $c_1, c_2, \dots, c_n$ ($1 \le c_i \le n$) β the colors of elements of the permutation.
It is guaranteed that the total sum of $n$ doesn't exceed $2 \cdot 10^5$.
-----Output-----
Print $T$ integers β one per test case. For each test case print minimum $k > 0$ such that $p^k$ has at least one infinite path.
-----Example-----
Input
3
4
1 3 4 2
1 2 2 3
5
2 3 4 5 1
1 2 3 4 5
8
7 4 5 6 1 8 3 2
5 3 6 4 7 5 8 4
Output
1
5
2
-----Note-----
In the first test case, $p^1 = p = [1, 3, 4, 2]$ and the sequence starting from $1$: $1, p[1] = 1, \dots$ is an infinite path.
In the second test case, $p^5 = [1, 2, 3, 4, 5]$ and it obviously contains several infinite paths.
In the third test case, $p^2 = [3, 6, 1, 8, 7, 2, 5, 4]$ and the sequence starting from $4$: $4, p^2[4]=8, p^2[8]=4, \dots$ is an infinite path since $c_4 = c_8 = 4$.
"""
| from sys import stdin
def atiSl():
input = stdin.readline
q = int(input())
for rwerew in range(q):
n = int(input())
p = list(map(int,input().split()))
c = list(map(int,input().split()))
for i in range(n):
p[i] -= 1
przyn = [0] * n
grupa = []
i = 0
while i < n:
if przyn[i] == 1:
i += 1
else:
nowa_grupa = [i]
j = p[i]
przyn[i] = 1
while j != i:
przyn[j] = 1
nowa_grupa.append(j)
j = p[j]
grupa.append(nowa_grupa)
grupacol = []
for i in grupa:
cyk = []
for j in i:
cyk.append(c[j])
grupacol.append(cyk)
#print(grupacol)
mini = 234283742834
for cykl in grupacol:
dziel = []
d = 1
while d**2 <= len(cykl):
if len(cykl)%d == 0:
dziel.append(d)
d += 1
dodat = []
for d in dziel:
dodat.append(len(cykl)/d)
dziel_ost = list(map(int,dziel + dodat))
#print(dziel_ost, len(cykl))
for dzielnik in dziel_ost:
for i in range(dzielnik):
indeks = i
secik = set()
chuj = True
while indeks < len(cykl):
secik.add(cykl[indeks])
indeks += dzielnik
if len(secik) > 1:
chuj = False
break
if chuj:
mini = min(mini, dzielnik)
print(mini)
| 3
4
1 3 4 2
1 2 2 3
5
2 3 4 5 1
1 2 3 4 5
8
7 4 5 6 1 8 3 2
5 3 6 4 7 5 8 4
| interview |
def dADoM():
"""β Hey folks, how do you like this problem?
β That'll do it.
BThero is a powerful magician. He has got $n$ piles of candies, the $i$-th pile initially contains $a_i$ candies. BThero can cast a copy-paste spell as follows: He chooses two piles $(i, j)$ such that $1 \le i, j \le n$ and $i \ne j$. All candies from pile $i$ are copied into pile $j$. Formally, the operation $a_j := a_j + a_i$ is performed.
BThero can cast this spell any number of times he wants to β but unfortunately, if some pile contains strictly more than $k$ candies, he loses his magic power. What is the maximum number of times BThero can cast the spell without losing his power?
-----Input-----
The first line contains one integer $T$ ($1 \le T \le 500$) β the number of test cases.
Each test case consists of two lines: the first line contains two integers $n$ and $k$ ($2 \le n \le 1000$, $2 \le k \le 10^4$); the second line contains $n$ integers $a_1$, $a_2$, ..., $a_n$ ($1 \le a_i \le k$).
It is guaranteed that the sum of $n$ over all test cases does not exceed $1000$, and the sum of $k$ over all test cases does not exceed $10^4$.
-----Output-----
For each test case, print one integer β the maximum number of times BThero can cast the spell without losing his magic power.
-----Example-----
Input
3
2 2
1 1
3 5
1 2 3
3 7
3 2 2
Output
1
5
4
-----Note-----
In the first test case we get either $a = [1, 2]$ or $a = [2, 1]$ after casting the spell for the first time, and it is impossible to cast it again.
"""
| import math
def dADoM():
t = int(input())
for test in range(t):
n,k = map(int,input().split())
A = list(map(int,input().split()))
A.sort()
ans = 0
for i in range(1,n):
if(A[i]>k):
ans = 0
break
rem = k-A[i]
ans+=rem//A[0]
print(ans) | 3
2 2
1 1
3 5
1 2 3
3 7
3 2 2
| interview |
def DZCUd():
"""Chaneka has a hobby of playing with animal toys. Every toy has a different fun value, a real number. Chaneka has four boxes to store the toys with specification: The first box stores toys with fun values in range of $(-\infty,-1]$. The second box stores toys with fun values in range of $(-1, 0)$. The third box stores toys with fun values in range of $(0, 1)$. The fourth box stores toys with fun value in range of $[1, \infty)$.
Chaneka has $A$, $B$, $C$, $D$ toys in the first, second, third, and fourth box, respectively. One day she decides that she only wants one toy, a super toy. So she begins to create this super toy by sewing all the toys she has.
While the number of toys Chaneka has is more than 1, she takes two different toys randomly and then sews them together, creating a new toy. The fun value of this new toy is equal to the multiplication of fun values of the sewn toys. She then puts this new toy in the appropriate box. She repeats this process until she only has one toy. This last toy is the super toy, and the box that stores this toy is the special box.
As an observer, you only know the number of toys in each box initially but do not know their fun values. You also don't see the sequence of Chaneka's sewing. Determine which boxes can be the special box after Chaneka found her super toy.
-----Input-----
The first line has an integer $T$ $(1 \le T \le 5 \cdot 10^4)$, the number of test cases.
Every case contains a line with four space-separated integers $A$ $B$ $C$ $D$ $(0 \le A, B, C, D \le 10^6, A + B + C + D > 0)$, which denotes the number of toys in the first, second, third, and fourth box, respectively.
-----Output-----
For each case, print four space-separated strings. Each string represents the possibility that the first, second, third, and fourth box can be the special box from left to right.
For each box, print "Ya" (Without quotes, Indonesian for yes) if that box can be the special box. Print "Tidak" (Without quotes, Indonesian for No) otherwise.
-----Example-----
Input
2
1 2 0 1
0 1 0 0
Output
Ya Ya Tidak Tidak
Tidak Ya Tidak Tidak
-----Note-----
For the first case, here is a scenario where the first box is the special box: The first box had toys with fun values $\{-3\}$. The second box had toys with fun values $\{ -0.5, -0.5 \}$ The fourth box had toys with fun values $\{ 3 \}$
The sewing sequence: Chaneka sews the toy with fun $-0.5$ and $-0.5$ to a toy with fun $0.25$ and then put it in the third box. Chaneka sews the toy with fun $-3$ and $0.25$ to a toy with fun $-0.75$ and then put it in the second box. Chaneka sews the toy with fun $-0.75$ and $3$ to a toy with fun $-1.25$ and then put it in the first box, which then became the special box.
Here is a scenario where the second box ends up being the special box: The first box had toys with fun values $\{-3\}$ The second box had toys with fun values $\{ -0.33, -0.25 \}$. The fourth box had toys with fun values $\{ 3 \}$.
The sewing sequence: Chaneka sews the toy with fun $-3$ and $-0.33$ to a toy with fun $0.99$ and then put it in the third box. Chaneka sews the toy with fun $0.99$ and $3$ to a toy with fun $2.97$ and then put in it the fourth box. Chaneka sews the toy with fun $2.97$ and $-0.25$ to a toy with fun $-0.7425$ and then put it in the second box, which then became the special box. There is only one toy for the second case, so Chaneka does not have to sew anything because that toy, by definition, is the super toy.
"""
|
def DZCUd():
t = int(input())
for _ in range(t):
a, b, c, d = [int(i) for i in input().split(" ")]
sgn = (a+b)%2
small = False
large = False
if a == 0 and d == 0:
small = True
if b == 0 and c == 0:
large = True
okay = [True] * 4
if sgn == 0:
okay[0] = False
okay[1] = False
else:
okay[2] = False
okay[3] = False
if small:
okay[0] = False
okay[3] = False
if large:
okay[1] = False
okay[2] = False
print(" ".join(["Ya" if okay[i] else "Tidak" for i in range(4)])) | 2
1 2 0 1
0 1 0 0
| interview |
def IvNpf():
"""You're given an array $a_1, \ldots, a_n$ of $n$ non-negative integers.
Let's call it sharpened if and only if there exists an integer $1 \le k \le n$ such that $a_1 < a_2 < \ldots < a_k$ and $a_k > a_{k+1} > \ldots > a_n$. In particular, any strictly increasing or strictly decreasing array is sharpened. For example: The arrays $[4]$, $[0, 1]$, $[12, 10, 8]$ and $[3, 11, 15, 9, 7, 4]$ are sharpened; The arrays $[2, 8, 2, 8, 6, 5]$, $[0, 1, 1, 0]$ and $[2, 5, 6, 9, 8, 8]$ are not sharpened.
You can do the following operation as many times as you want: choose any strictly positive element of the array, and decrease it by one. Formally, you can choose any $i$ ($1 \le i \le n$) such that $a_i>0$ and assign $a_i := a_i - 1$.
Tell if it's possible to make the given array sharpened using some number (possibly zero) of these operations.
-----Input-----
The input consists of multiple test cases. The first line contains a single integer $t$ ($1 \le t \le 15\ 000$) Β β 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 3 \cdot 10^5$).
The second line of each test case contains a sequence of $n$ non-negative integers $a_1, \ldots, a_n$ ($0 \le a_i \le 10^9$).
It is guaranteed that the sum of $n$ over all test cases does not exceed $3 \cdot 10^5$.
-----Output-----
For each test case, output a single line containing "Yes" (without quotes) if it's possible to make the given array sharpened using the described operations, or "No" (without quotes) otherwise.
-----Example-----
Input
10
1
248618
3
12 10 8
6
100 11 15 9 7 8
4
0 1 1 0
2
0 0
2
0 1
2
1 0
2
1 1
3
0 1 0
3
1 0 1
Output
Yes
Yes
Yes
No
No
Yes
Yes
Yes
Yes
No
-----Note-----
In the first and the second test case of the first test, the given array is already sharpened.
In the third test case of the first test, we can transform the array into $[3, 11, 15, 9, 7, 4]$ (decrease the first element $97$ times and decrease the last element $4$ times). It is sharpened because $3 < 11 < 15$ and $15 > 9 > 7 > 4$.
In the fourth test case of the first test, it's impossible to make the given array sharpened.
"""
|
def IvNpf():
for _ in range(int(input())):
n=int(input())
li=list(map(int,input().split()))
ans=0
for i in range(n):
if li[i]>=i:
ans+=1
else:
break
for i in range(n):
if li[n-1-i]>=i:
ans+=1
else:
break
if ans>n:
print("Yes")
else:
print("No") | 10
1
248618
3
12 10 8
6
100 11 15 9 7 8
4
0 1 1 0
2
0 0
2
0 1
2
1 0
2
1 1
3
0 1 0
3
1 0 1
| interview |
def GSkUm():
"""You have a bag of size $n$. Also you have $m$ boxes. The size of $i$-th box is $a_i$, where each $a_i$ is an integer non-negative power of two.
You can divide boxes into two parts of equal size. Your goal is to fill the bag completely.
For example, if $n = 10$ and $a = [1, 1, 32]$ then you have to divide the box of size $32$ into two parts of size $16$, and then divide the box of size $16$. So you can fill the bag with boxes of size $1$, $1$ and $8$.
Calculate the minimum number of divisions required to fill the bag of size $n$.
-----Input-----
The first line contains one integer $t$ ($1 \le t \le 1000$) β the number of test cases.
The first line of each test case contains two integers $n$ and $m$ ($1 \le n \le 10^{18}, 1 \le m \le 10^5$) β the size of bag and the number of boxes, respectively.
The second line of each test case contains $m$ integers $a_1, a_2, \dots , a_m$ ($1 \le a_i \le 10^9$) β the sizes of boxes. It is guaranteed that each $a_i$ is a power of two.
It is also guaranteed that sum of all $m$ over all test cases does not exceed $10^5$.
-----Output-----
For each test case print one integer β the minimum number of divisions required to fill the bag of size $n$ (or $-1$, if it is impossible).
-----Example-----
Input
3
10 3
1 32 1
23 4
16 1 4 1
20 5
2 1 16 1 8
Output
2
-1
0
"""
| import sys
import math
from collections import defaultdict
from collections import deque
from itertools import combinations
from itertools import permutations
def GSkUm():
input = lambda : sys.stdin.readline().rstrip()
read = lambda : list(map(int, input().split()))
go = lambda : 1/0
def write(*args, sep="\n"):
for i in args:
sys.stdout.write("{}{}".format(i, sep))
INF = float('inf')
MOD = int(1e9 + 7)
YES = "YES"
NO = -1
for _ in range(int(input())):
try:
n, m = read()
arr = read()
x = [0] * 65
if sum(arr) < n:
print(NO)
go()
for i in arr:
x[int(math.log2(i))] += 1
ans = 0
for i in range(65):
if (1 << i) & n:
if x[i] != 0:
x[i] -= 1
continue
total = 0
for j in range(i):
total += (1 << j) * x[j]
if total >= (1 << i):
temp = 1 << i
for j in reversed(range(i)):
while temp - (1 << j) >= 0 and x[j] > 0:
temp -= 1 << j
x[j] -= 1
continue
j = i
while j < 65 and x[j] == 0:
j += 1
if j == 65:
print(NO)
go()
else:
x[j] -= 1
for k in range(i, j):
x[k] += 1
ans += (j - i)
print(ans)
except ZeroDivisionError:
continue
except Exception as e:
print(e)
continue | 3
10 3
1 32 1
23 4
16 1 4 1
20 5
2 1 16 1 8
| interview |
def zODYL():
"""On February 14 Denis decided to give Valentine to Nastya and did not come up with anything better than to draw a huge red heart on the door of the length $k$ ($k \ge 3$). Nastya was very confused by this present, so she decided to break the door, throwing it on the mountains.
Mountains are described by a sequence of heights $a_1, a_2, \dots, a_n$ in order from left to right ($k \le n$). It is guaranteed that neighboring heights are not equal to each other (that is, $a_i \ne a_{i+1}$ for all $i$ from $1$ to $n-1$).
Peaks of mountains on the segment $[l,r]$ (from $l$ to $r$) are called indexes $i$ such that $l < i < r$, $a_{i - 1} < a_i$ and $a_i > a_{i + 1}$. It is worth noting that the boundary indexes $l$ and $r$ for the segment are not peaks. For example, if $n=8$ and $a=[3,1,4,1,5,9,2,6]$, then the segment $[1,8]$ has only two peaks (with indexes $3$ and $6$), and there are no peaks on the segment $[3, 6]$.
To break the door, Nastya throws it to a segment $[l,l+k-1]$ of consecutive mountains of length $k$ ($1 \le l \le n-k+1$). When the door touches the peaks of the mountains, it breaks into two parts, after that these parts will continue to fall in different halves and also break into pieces when touching the peaks of the mountains, and so on. Formally, the number of parts that the door will break into will be equal to $p+1$, where $p$ is the number of peaks on the segment $[l,l+k-1]$.
Nastya wants to break it into as many pieces as possible. Help her choose such a segment of mountains $[l, l+k-1]$ that the number of peaks on it is maximum. If there are several optimal segments, Nastya wants to find one for which the value $l$ is minimal.
Formally, you need to choose a segment of mountains $[l, l+k-1]$ that has the maximum number of peaks. Among all such segments, you need to find the segment that has the minimum possible value $l$.
-----Input-----
The first line contains an integer $t$ ($1 \leq t \leq 10^4$) Β β the number of test cases. Then the descriptions of the test cases follow.
The first line of each test case contains two integers $n$ and $k$ ($3 \leq k \leq n \leq 2 \cdot 10^5$) Β β the number of mountains and the length of the door.
The second line of the input data set contains $n$ integers $a_1, a_2, \dots, a_n$ ($0 \leq a_i \leq 10 ^ 9$, $a_i \neq a_{i + 1}$) Β β the heights of mountains.
It is guaranteed that the sum of $n$ over all the test cases will not exceed $2 \cdot 10^5$.
-----Output-----
For each test case, output two integers $t$ and $l$ Β β the maximum number of parts that the door can split into, and the left border of the segment of length $k$ that the door should be reset to.
-----Example-----
Input
5
8 6
1 2 4 1 2 4 1 2
5 3
3 2 3 2 1
10 4
4 3 4 3 2 3 2 1 0 1
15 7
3 7 4 8 2 3 4 5 21 2 3 4 2 1 3
7 5
1 2 3 4 5 6 1
Output
3 2
2 2
2 1
3 1
2 3
-----Note-----
In the first example, you need to select a segment of mountains from $2$ to $7$. In this segment, the indexes $3$ and $6$ are peaks, so the answer is $3$ (only $2$ peaks, so the door will break into $3$ parts). It is not difficult to notice that the mountain segments $[1, 6]$ and $[3, 8]$ are not suitable since they only have a $1$ peak (for the first segment, the $6$ index is not a peak, and for the second segment, the $3$ index is not a peak).
In the second example, you need to select a segment of mountains from $2$ to $4$. In this segment, the index $3$ is a peak, so the answer is $2$ (only $1$ peak, so the door will break into $2$ parts).
In the third example, you need to select a segment of mountains from $1$ to $4$. In this segment, the index $3$ is a peak, so the answer is $2$ (only $1$ peak, so the door will break into $2$ parts). You can see that on the segments $[2, 5]$, $[4, 7]$ and $[5, 8]$ the number of peaks is also $1$, but these segments have a left border greater than the segment $[1, 4]$, so they are not the correct answer.
"""
|
def zODYL():
for _ in range(int(input())):
n, k = tuple(map(int, input().split()))
arr = list(map(int, input().split()))
peaks = [0 for i in range(n)]
for i in range(1, n - 1):
if arr[i] > arr[i - 1] and arr[i] > arr[i + 1]:
peaks[i] = 1
cnt = 0
max_peaks = 0
answer = 0
for i in range(k - 1):
cnt += peaks[i]
max_peaks += peaks[i]
for i in range(k - 1, n - 1):
cnt -= peaks[i - k + 2]
cnt += peaks[i]
if cnt > max_peaks:
max_peaks = cnt
answer = i - k + 2
print(max_peaks + 1, answer + 1)
| 5
8 6
1 2 4 1 2 4 1 2
5 3
3 2 3 2 1
10 4
4 3 4 3 2 3 2 1 0 1
15 7
3 7 4 8 2 3 4 5 21 2 3 4 2 1 3
7 5
1 2 3 4 5 6 1
| interview |
def rTkMC():
"""You are given an image, that can be represented with a 2-d n by m grid of pixels. Each pixel of the image is either on or off, denoted by the characters "0" or "1", respectively. You would like to compress this image. You want to choose an integer k > 1 and split the image into k by k blocks. If n and m are not divisible by k, the image is padded with only zeros on the right and bottom so that they are divisible by k. Each pixel in each individual block must have the same value. The given image may not be compressible in its current state. Find the minimum number of pixels you need to toggle (after padding) in order for the image to be compressible for some k. More specifically, the steps are to first choose k, then the image is padded with zeros, then, we can toggle the pixels so it is compressible for this k. The image must be compressible in that state.
-----Input-----
The first line of input will contain two integers n, m (2 β€ n, m β€ 2 500), the dimensions of the image.
The next n lines of input will contain a binary string with exactly m characters, representing the image.
-----Output-----
Print a single integer, the minimum number of pixels needed to toggle to make the image compressible.
-----Example-----
Input
3 5
00100
10110
11001
Output
5
-----Note-----
We first choose k = 2.
The image is padded as follows:
001000
101100
110010
000000
We can toggle the image to look as follows:
001100
001100
000000
000000
We can see that this image is compressible for k = 2.
"""
| from sys import stdin
def rTkMC():
#!/usr/bin/env python
# coding:utf-8
# Copyright (C) dirlt
def run(n, m, pixels):
ans = 1 << 30
acc = [[0] * (m + 1) for _ in range(n + 1)]
for i in range(n):
for j in range(m):
acc[i + 1][j + 1] = acc[i + 1][j] + int(pixels[i][j])
for j in range(m):
acc[i + 1][j + 1] += acc[i][j + 1]
# print(acc)
for k in range(2, max(n, m) + 1):
r, c = (n + k - 1) // k, (m + k - 1) // k
res = 0
for i in range(r):
for j in range(c):
x, y = i * k, j * k
x2, y2 = min(x + k - 1, n - 1), min(y + k - 1, m - 1)
zero = acc[x2 + 1][y2 + 1] - acc[x][y2 + 1] - acc[x2 + 1][y] + acc[x][y]
# print(x, y, k, zero, k * k - zero)
res += min(zero, k * k - zero)
# print(k, res)
ans = min(ans, res)
print(ans)
def main():
n, m = [int(x) for x in stdin.readline().split()]
pixels = []
for i in range(n):
pixels.append(stdin.readline().strip())
run(n, m, pixels)
def __starting_point():
import os
if os.path.exists('tmp.in'):
stdin = open('tmp.in')
main()
__starting_point() | 3 5
00100
10110
11001
| interview |
def PKVEJ():
"""Now that Heidi has made sure her Zombie Contamination level checker works, it's time to strike! This time, the zombie lair is a strictly convex polygon on the lattice. Each vertex of the polygon occupies a point on the lattice. For each cell of the lattice, Heidi knows the level of Zombie Contamination β the number of corners of the cell that are inside or on the border of the lair.
Given this information, Heidi wants to know the exact shape of the lair to rain destruction on the zombies. Help her!
[Image]
-----Input-----
The input contains multiple test cases.
The first line of each test case contains one integer N, the size of the lattice grid (5 β€ N β€ 500). The next N lines each contain N characters, describing the level of Zombie Contamination of each cell in the lattice. Every character of every line is a digit between 0 and 4.
Cells are given in the same order as they are shown in the picture above: rows go in the decreasing value of y coordinate, and in one row cells go in the order of increasing x coordinate. This means that the first row corresponds to cells with coordinates (1, N), ..., (N, N) and the last row corresponds to cells with coordinates (1, 1), ..., (N, 1).
The last line of the file contains a zero. This line should not be treated as a test case. The sum of the N values for all tests in one file will not exceed 5000.
-----Output-----
For each test case, give the following output:
The first line of the output should contain one integer V, the number of vertices of the polygon that is the secret lair. The next V lines each should contain two integers, denoting the vertices of the polygon in the clockwise order, starting from the lexicographically smallest vertex.
-----Examples-----
Input
8
00000000
00000110
00012210
01234200
02444200
01223200
00001100
00000000
5
00000
01210
02420
01210
00000
7
0000000
0122100
0134200
0013200
0002200
0001100
0000000
0
Output
4
2 3
2 4
6 6
5 2
4
2 2
2 3
3 3
3 2
3
2 5
4 5
4 2
-----Note-----
It is guaranteed that the solution always exists and is unique. It is guaranteed that in the correct solution the coordinates of the polygon vertices are between 2 and N - 2. A vertex (x_1, y_1) is lexicographically smaller than vertex (x_2, y_2) if x_1 < x_2 or $x_{1} = x_{2} \wedge y_{1} < y_{2}$.
"""
| import math
def PKVEJ():
def lexComp(a, b):
if a[0] != b[0]:
return -1 if a[0] < b[0] else 1
if a[1] != b[1]:
return -1 if a[1] < b[1] else 1
return 0
def turn(a, b, c):
return (b[0] - a[0]) * (c[1] - b[1]) - (b[1] - a[1]) * (c[0] - b[0])
def dist2(a, b):
return (a[0] - b[0]) ** 2 + (a[1] - b[1]) ** 2
def solve(n):
a = [list(map(int, input())) for _ in range(n)]
points = []
for i in range(n):
for j in range(n):
if a[i][j] == 1:
curPoints = []
for dx in range(0, 2):
for dy in range(0, 2):
ok = True
for ddx in range(0, 2):
for ddy in range(0, 2):
x, y = i - 1 + dx + ddx, j - 1 + dy + ddy
if 0 <= x < n and 0 <= y < n and a[x][y] == 0:
ok = False
if ok:
curPoints.append((i + dx, j + dy))
points.append(curPoints[0])
points = list(set(points))
for i in range(1, len(points)):
if lexComp(points[0], points[i]) > 0:
points[0], points[i] = points[i], points[0]
points[1:] = sorted(points[1:], key=lambda p: (math.atan2(p[1] - points[0][1], p[0] - points[0][0]), dist2(p, points[0])))
hull = []
for p in points:
while len(hull) >= 2 and turn(hull[-2], hull[-1], p) <= 0:
hull.pop()
hull.append(p)
hull = [(p[1], n - p[0]) for p in hull]
hull = hull[::-1]
start = 0
for i in range(1, len(hull)):
if lexComp(hull[i], hull[start]) < 0:
start = i
newHull = hull[start:]
newHull.extend(hull[:start])
hull = newHull
print(len(hull))
for p in hull:
print(p[0], p[1])
while True:
n = int(input())
if n == 0:
break
solve(n) | 8
00000000
00000110
00012210
01234200
02444200
01223200
00001100
00000000
5
00000
01210
02420
01210
00000
7
0000000
0122100
0134200
0013200
0002200
0001100
0000000
0
| interview |
def zOGnx():
"""Bob watches TV every day. He always sets the volume of his TV to $b$. However, today he is angry to find out someone has changed the volume to $a$. Of course, Bob has a remote control that can change the volume.
There are six buttons ($-5, -2, -1, +1, +2, +5$) on the control, which in one press can either increase or decrease the current volume by $1$, $2$, or $5$. The volume can be arbitrarily large, but can never be negative. In other words, Bob cannot press the button if it causes the volume to be lower than $0$.
As Bob is so angry, he wants to change the volume to $b$ using as few button presses as possible. However, he forgets how to do such simple calculations, so he asks you for help. Write a program that given $a$ and $b$, finds the minimum number of presses to change the TV volume from $a$ to $b$.
-----Input-----
Each test contains multiple test cases. The first line contains the number of test cases $T$ ($1 \le T \le 1\,000$). Then the descriptions of the test cases follow.
Each test case consists of one line containing two integers $a$ and $b$ ($0 \le a, b \le 10^{9}$)Β β the current volume and Bob's desired volume, respectively.
-----Output-----
For each test case, output a single integerΒ β the minimum number of presses to change the TV volume from $a$ to $b$. If Bob does not need to change the volume (i.e. $a=b$), then print $0$.
-----Example-----
Input
3
4 0
5 14
3 9
Output
2
3
2
-----Note-----
In the first example, Bob can press the $-2$ button twice to reach $0$. Note that Bob can not press $-5$ when the volume is $4$ since it will make the volume negative.
In the second example, one of the optimal ways for Bob is to press the $+5$ twice, then press $-1$ once.
In the last example, Bob can press the $+5$ once, then press $+1$.
"""
| import math
from decimal import Decimal
import heapq
from collections import deque
def zOGnx():
def na():
n = int(input())
b = [int(x) for x in input().split()]
return n,b
def nab():
n = int(input())
b = [int(x) for x in input().split()]
c = [int(x) for x in input().split()]
return n,b,c
def dv():
n, m = list(map(int, input().split()))
return n,m
def dva():
n, m = list(map(int, input().split()))
a = [int(x) for x in input().split()]
b = [int(x) for x in input().split()]
return n,m,b
def eratosthenes(n):
sieve = list(range(n + 1))
for i in sieve:
if i > 1:
for j in range(i + i, len(sieve), i):
sieve[j] = 0
return sorted(set(sieve))
def lol(lst,k):
k=k%len(lst)
ret=[0]*len(lst)
for i in range(len(lst)):
if i+k<len(lst) and i+k>=0:
ret[i]=lst[i+k]
if i+k>=len(lst):
ret[i]=lst[i+k-len(lst)]
if i+k<0:
ret[i]=lst[i+k+len(lst)]
return(ret)
def nm():
n = int(input())
b = [int(x) for x in input().split()]
m = int(input())
c = [int(x) for x in input().split()]
return n,b,m,c
def dvs():
n = int(input())
m = int(input())
return n, m
def fact(a, b):
c = []
ans = 0
f = int(math.sqrt(a))
for i in range(1, f + 1):
if a % i == 0:
c.append(i)
l = len(c)
for i in range(l):
c.append(a // c[i])
for i in range(len(c)):
if c[i] <= b:
ans += 1
if a / f == f and b >= f:
return ans - 1
return ans
t = int(input())
for i in range(t):
a ,b = list(map(int, input().split()))
if a == b:
print(0)
else:
d = abs(a - b)
k1 = d//5
d -= k1 *5
k2 = d // 2
d -= k2 * 2
print(d + k1 + k2) | 3
4 0
5 14
3 9
| interview |
def zdfsx():
"""You play a computer game. In this game, you lead a party of $m$ heroes, and you have to clear a dungeon with $n$ monsters. Each monster is characterized by its power $a_i$. Each hero is characterized by his power $p_i$ and endurance $s_i$.
The heroes clear the dungeon day by day. In the beginning of each day, you choose a hero (exactly one) who is going to enter the dungeon this day.
When the hero enters the dungeon, he is challenged by the first monster which was not defeated during the previous days (so, if the heroes have already defeated $k$ monsters, the hero fights with the monster $k + 1$). When the hero fights the monster, there are two possible outcomes:
if the monster's power is strictly greater than the hero's power, the hero retreats from the dungeon. The current day ends; otherwise, the monster is defeated.
After defeating a monster, the hero either continues fighting with the next monster or leaves the dungeon. He leaves the dungeon either if he has already defeated the number of monsters equal to his endurance during this day (so, the $i$-th hero cannot defeat more than $s_i$ monsters during each day), or if all monsters are defeated β otherwise, he fights with the next monster. When the hero leaves the dungeon, the current day ends.
Your goal is to defeat the last monster. What is the minimum number of days that you need to achieve your goal? Each day you have to use exactly one hero; it is possible that some heroes don't fight the monsters at all. Each hero can be used arbitrary number of times.
-----Input-----
The first line contains one integer $t$ ($1 \le t \le 10^5$) β the number of test cases. Then the test cases follow.
The first line of each test case contains one integer $n$ ($1 \le n \le 2 \cdot 10^5$) β the number of monsters in the dungeon.
The second line contains $n$ integers $a_1$, $a_2$, ..., $a_n$ ($1 \le a_i \le 10^9$), where $a_i$ is the power of the $i$-th monster.
The third line contains one integer $m$ ($1 \le m \le 2 \cdot 10^5$) β the number of heroes in your party.
Then $m$ lines follow, each describing a hero. Each line contains two integers $p_i$ and $s_i$ ($1 \le p_i \le 10^9$, $1 \le s_i \le n$) β the power and the endurance of the $i$-th hero.
It is guaranteed that the sum of $n + m$ over all test cases does not exceed $2 \cdot 10^5$.
-----Output-----
For each test case print one integer β the minimum number of days you have to spend to defeat all of the monsters (or $-1$ if it is impossible).
-----Example-----
Input
2
6
2 3 11 14 1 8
2
3 2
100 1
5
3 5 100 2 3
2
30 5
90 1
Output
5
-1
"""
| import sys
import bisect
def zdfsx():
input = sys.stdin.readline
t=int(input())
for testcases in range(t):
n=int(input())
A=list(map(int,input().split()))
m=int(input())
PS=[tuple(map(int,input().split())) for i in range(m)]
PS.sort()
K=[PS[-1]]
for a,b in PS[::-1][1:]:
if b<=K[-1][1]:
continue
else:
K.append((a,b))
K.reverse()
ANS=1
count=0
countmax=n+1
LEN=len(K)
for a in A:
x=bisect.bisect_left(K,(a,0))
if x==LEN:
print(-1)
break
elif K[x][1]>=count+1 and countmax>=count+1:
count+=1
countmax=min(countmax,K[x][1])
else:
ANS+=1
count=1
countmax=K[x][1]
#print(a,count,countmax,ANS)
else:
print(ANS)
| 2
6
2 3 11 14 1 8
2
3 2
100 1
5
3 5 100 2 3
2
30 5
90 1
| interview |
def YtUIG():
"""All techniques in the ninja world consist of hand seals. At the moment Naruto is learning a new technique, which consists of $n\cdot m$ different seals, denoted by distinct numbers. All of them were written in an $n\times m$ table.
The table is lost now. Naruto managed to remember elements of each row from left to right, and elements of each column from top to bottom, but he doesn't remember the order of rows and columns. Please restore the table consistent with this data so that Naruto will be able to learn the new technique.
-----Input-----
The first line of the input contains the only integer $t$ ($1\leq t\leq 100\,000$) denoting the number of test cases. Their descriptions follow.
The first line of each test case description consists of two space-separated integers $n$ and $m$ ($1 \leq n, m \leq 500$) standing for the number of rows and columns in the table, respectively. All hand seals are encoded by the positive integers from $1$ to $n\cdot m$.
The following $n$ lines contain $m$ space separated integers each, denoting elements of an arbitrary row in the table left to right.
The following $m$ lines contain $n$ space separated integers each, denoting elements of an arbitrary column in the table top to bottom.
Sum of $nm$ over all test cases does not exceed $250\,000$. It is guaranteed that each row occurs in the input exactly once, as well as each column. It is also guaranteed that each number from $1$ to $nm$ occurs exactly once in all rows, as well as in all columns. Finally, it is guaranteed that a table consistent with the input exists.
-----Output-----
For each test case, output $n$ lines with $m$ space-separated integers each, denoting the restored table. One can show that the answer is always unique.
-----Example-----
Input
2
2 3
6 5 4
1 2 3
1 6
2 5
3 4
3 1
2
3
1
3 1 2
Output
1 2 3
6 5 4
3
1
2
-----Note-----
Consider the first test case. The matrix is $2 \times 3$. You are given the rows and columns in arbitrary order.
One of the rows is $[6, 5, 4]$. One of the rows is $[1, 2, 3]$.
One of the columns is $[1, 6]$. One of the columns is $[2, 5]$. One of the columns is $[3, 4]$.
You are to reconstruct the matrix. The answer is given in the output.
"""
| from sys import stdin
def YtUIG():
input = stdin.readline
tests = int(input())
for test in range(tests):
n, m = list(map(int, input().split()))
a = [[0] * m for _ in range(n)]
r = [[int(i) for i in input().split()] for _ in range(n)]
c = [[int(i) for i in input().split()] for _ in range(m)]
z = [[-1, -1] for _ in range(n * m + 1)]
for i in range(n):
for j in range(m):
z[r[i][j]][0] = j
for i in range(m):
for j in range(n):
z[c[i][j]][1] = j
for i in range(1, n * m + 1):
a[z[i][1]][z[i][0]] = i
for i in a:
print(' '.join([str(j) for j in i])) | 2
2 3
6 5 4
1 2 3
1 6
2 5
3 4
3 1
2
3
1
3 1 2
| interview |
def aDAmY():
"""There are $n$ programmers that you want to split into several non-empty teams. The skill of the $i$-th programmer is $a_i$. You want to assemble the maximum number of teams from them. There is a restriction for each team: the number of programmers in the team multiplied by the minimum skill among all programmers in the team must be at least $x$.
Each programmer should belong to at most one team. Some programmers may be left without a team.
Calculate the maximum number of teams that you can assemble.
-----Input-----
The first line contains the integer $t$ ($1 \le t \le 1000$)Β β the number of test cases.
The first line of each test case contains two integers $n$ and $x$ ($1 \le n \le 10^5; 1 \le x \le 10^9$)Β β the number of programmers and the restriction of team skill respectively.
The second line of each test case contains $n$ integers $a_1, a_2, \dots , a_n$ ($1 \le a_i \le 10^9$), where $a_i$ is the skill of the $i$-th programmer.
The sum of $n$ over all inputs does not exceed $10^5$.
-----Output-----
For each test case print one integer β the maximum number of teams that you can assemble.
-----Example-----
Input
3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
Output
2
1
0
"""
|
def aDAmY():
__MULTITEST = True
## solve
def solve():
n, x = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
group = 0
ptr = n-1
members = 0
currentMin = int(1e10)
while ptr > -1:
currentMin = min(currentMin, a[ptr])
members += 1
if currentMin * members >= x:
group += 1
members = 0
currentMin = int(1e10)
ptr -= 1
print(group)
## main
def __starting_point():
t = (int(input()) if __MULTITEST else 1)
for tt in range(t):
solve();
__starting_point() | 3
5 10
7 11 2 9 5
4 8
2 4 2 3
4 11
1 3 3 7
| interview |
def hWLKd():
"""Assume that you have $k$ one-dimensional segments $s_1, s_2, \dots s_k$ (each segment is denoted by two integers β its endpoints). Then you can build the following graph on these segments. The graph consists of $k$ vertexes, and there is an edge between the $i$-th and the $j$-th vertexes ($i \neq j$) if and only if the segments $s_i$ and $s_j$ intersect (there exists at least one point that belongs to both of them).
For example, if $s_1 = [1, 6], s_2 = [8, 20], s_3 = [4, 10], s_4 = [2, 13], s_5 = [17, 18]$, then the resulting graph is the following: [Image]
A tree of size $m$ is good if it is possible to choose $m$ one-dimensional segments so that the graph built on these segments coincides with this tree.
You are given a tree, you have to find its good subtree with maximum possible size. Recall that a subtree is a connected subgraph of a tree.
Note that you have to answer $q$ independent queries.
-----Input-----
The first line contains one integer $q$ ($1 \le q \le 15 \cdot 10^4$) β the number of the queries.
The first line of each query contains one integer $n$ ($2 \le n \le 3 \cdot 10^5$) β the number of vertices in the tree.
Each of the next $n - 1$ lines contains two integers $x$ and $y$ ($1 \le x, y \le n$) denoting an edge between vertices $x$ and $y$. It is guaranteed that the given graph is a tree.
It is guaranteed that the sum of all $n$ does not exceed $3 \cdot 10^5$.
-----Output-----
For each query print one integer β the maximum size of a good subtree of the given tree.
-----Example-----
Input
1
10
1 2
1 3
1 4
2 5
2 6
3 7
3 8
4 9
4 10
Output
8
-----Note-----
In the first query there is a good subtree of size $8$. The vertices belonging to this subtree are ${9, 4, 10, 2, 5, 1, 6, 3}$.
"""
| import sys
def hWLKd():
input = sys.stdin.readline
t = int(input())
for _ in range(t):
n = int(input())
ab = [list(map(int,input().split())) for i in range(n-1)]
graph = [[] for i in range(n+1)]
deg = [0]*(n+1)
for a,b in ab:
graph[a].append(b)
graph[b].append(a)
deg[a] += 1
deg[b] += 1
pnt = [max(deg[i]-1,1) for i in range(n+1)]
root = 1
stack = [root]
dist = [0]*(n+1)
dist[root] = pnt[root]
while stack:
x = stack.pop()
for y in graph[x]:
if dist[y] == 0:
dist[y] = dist[x]+pnt[y]
stack.append(y)
far = dist.index(max(dist))
root = far
stack = [root]
dist = [0]*(n+1)
dist[root] = pnt[root]
while stack:
x = stack.pop()
for y in graph[x]:
if dist[y] == 0:
dist[y] = dist[x]+pnt[y]
stack.append(y)
print(max(dist)) | 1
10
1 2
1 3
1 4
2 5
2 6
3 7
3 8
4 9
4 10
| interview |
def TsPkK():
"""Ayoub thinks that he is a very smart person, so he created a function $f(s)$, where $s$ is a binary string (a string which contains only symbols "0" and "1"). The function $f(s)$ is equal to the number of substrings in the string $s$ that contains at least one symbol, that is equal to "1".
More formally, $f(s)$ is equal to the number of pairs of integers $(l, r)$, such that $1 \leq l \leq r \leq |s|$ (where $|s|$ is equal to the length of string $s$), such that at least one of the symbols $s_l, s_{l+1}, \ldots, s_r$ is equal to "1".
For example, if $s = $"01010" then $f(s) = 12$, because there are $12$ such pairs $(l, r)$: $(1, 2), (1, 3), (1, 4), (1, 5), (2, 2), (2, 3), (2, 4), (2, 5), (3, 4), (3, 5), (4, 4), (4, 5)$.
Ayoub also thinks that he is smarter than Mahmoud so he gave him two integers $n$ and $m$ and asked him this problem. For all binary strings $s$ of length $n$ which contains exactly $m$ symbols equal to "1", find the maximum value of $f(s)$.
Mahmoud couldn't solve the problem so he asked you for help. Can you help him?
-----Input-----
The input consists of multiple test cases. The first line contains a single integer $t$ ($1 \leq t \leq 10^5$) Β β the number of test cases. The description of the test cases follows.
The only line for each test case contains two integers $n$, $m$ ($1 \leq n \leq 10^{9}$, $0 \leq m \leq n$)Β β the length of the string and the number of symbols equal to "1" in it.
-----Output-----
For every test case print one integer numberΒ β the maximum value of $f(s)$ over all strings $s$ of length $n$, which has exactly $m$ symbols, equal to "1".
-----Example-----
Input
5
3 1
3 2
3 3
4 0
5 2
Output
4
5
6
0
12
-----Note-----
In the first test case, there exists only $3$ strings of length $3$, which has exactly $1$ symbol, equal to "1". These strings are: $s_1 = $"100", $s_2 = $"010", $s_3 = $"001". The values of $f$ for them are: $f(s_1) = 3, f(s_2) = 4, f(s_3) = 3$, so the maximum value is $4$ and the answer is $4$.
In the second test case, the string $s$ with the maximum value is "101".
In the third test case, the string $s$ with the maximum value is "111".
In the fourth test case, the only string $s$ of length $4$, which has exactly $0$ symbols, equal to "1" is "0000" and the value of $f$ for that string is $0$, so the answer is $0$.
In the fifth test case, the string $s$ with the maximum value is "01010" and it is described as an example in the problem statement.
"""
| import sys
def TsPkK():
input = sys.stdin.readline
t=int(input())
def calc(x):
return x*(x+1)//2
for test in range(t):
n,m=list(map(int,input().split()))
ANS=calc(n)
k=n-m
q,mod=divmod(k,m+1)
ANS-=calc(q+1)*mod+calc(q)*(m+1-mod)
print(ANS)
| 5
3 1
3 2
3 3
4 0
5 2
| interview |