index
int64 0
5.16k
| difficulty
int64 7
12
| question
stringlengths 126
7.12k
| solution
stringlengths 30
18.6k
| test_cases
dict |
|---|---|---|---|---|
2,000 | 8 | Vika has n jars with paints of distinct colors. All the jars are numbered from 1 to n and the i-th jar contains ai liters of paint of color i.
Vika also has an infinitely long rectangular piece of paper of width 1, consisting of squares of size 1 Γ 1. Squares are numbered 1, 2, 3 and so on. Vika decided that she will start painting squares one by one from left to right, starting from the square number 1 and some arbitrary color. If the square was painted in color x, then the next square will be painted in color x + 1. In case of x = n, next square is painted in color 1. If there is no more paint of the color Vika wants to use now, then she stops.
Square is always painted in only one color, and it takes exactly 1 liter of paint. Your task is to calculate the maximum number of squares that might be painted, if Vika chooses right color to paint the first square.
Input
The first line of the input contains a single integer n (1 β€ n β€ 200 000) β the number of jars with colors Vika has.
The second line of the input contains a sequence of integers a1, a2, ..., an (1 β€ ai β€ 109), where ai is equal to the number of liters of paint in the i-th jar, i.e. the number of liters of color i that Vika has.
Output
The only line of the output should contain a single integer β the maximum number of squares that Vika can paint if she follows the rules described above.
Examples
Input
5
2 4 2 3 3
Output
12
Input
3
5 5 5
Output
15
Input
6
10 10 10 1 10 10
Output
11
Note
In the first sample the best strategy is to start painting using color 4. Then the squares will be painted in the following colors (from left to right): 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5.
In the second sample Vika can start to paint using any color.
In the third sample Vika should start painting using color number 5. | n=int(input())
l=list(map(int,input().split()))
def paint(l):
n=len(l)
m=min(l)
a=[]
t=0
for i in range(n):
if l[i]==m:
a.append(i)
t+=1
b=[]
for j in range(t-1):
b.append(a[j+1]-a[j])
b.append(n-a[t-1]+a[0])
return m*n+max(b)-1
print(paint(l)) | {
"input": [
"5\n2 4 2 3 3\n",
"3\n5 5 5\n",
"6\n10 10 10 1 10 10\n"
],
"output": [
"12\n",
"15\n",
"11\n"
]
} |
2,001 | 10 | Maria participates in a bicycle race.
The speedway takes place on the shores of Lake Lucerne, just repeating its contour. As you know, the lake shore consists only of straight sections, directed to the north, south, east or west.
Let's introduce a system of coordinates, directing the Ox axis from west to east, and the Oy axis from south to north. As a starting position of the race the southernmost point of the track is selected (and if there are several such points, the most western among them). The participants start the race, moving to the north. At all straight sections of the track, the participants travel in one of the four directions (north, south, east or west) and change the direction of movement only in bends between the straight sections. The participants, of course, never turn back, that is, they do not change the direction of movement from north to south or from east to west (or vice versa).
Maria is still young, so she does not feel confident at some turns. Namely, Maria feels insecure if at a failed or untimely turn, she gets into the water. In other words, Maria considers the turn dangerous if she immediately gets into the water if it is ignored.
Help Maria get ready for the competition β determine the number of dangerous turns on the track.
Input
The first line of the input contains an integer n (4 β€ n β€ 1000) β the number of straight sections of the track.
The following (n + 1)-th line contains pairs of integers (xi, yi) ( - 10 000 β€ xi, yi β€ 10 000). The first of these points is the starting position. The i-th straight section of the track begins at the point (xi, yi) and ends at the point (xi + 1, yi + 1).
It is guaranteed that:
* the first straight section is directed to the north;
* the southernmost (and if there are several, then the most western of among them) point of the track is the first point;
* the last point coincides with the first one (i.e., the start position);
* any pair of straight sections of the track has no shared points (except for the neighboring ones, they share exactly one point);
* no pair of points (except for the first and last one) is the same;
* no two adjacent straight sections are directed in the same direction or in opposite directions.
Output
Print a single integer β the number of dangerous turns on the track.
Examples
Input
6
0 0
0 1
1 1
1 2
2 2
2 0
0 0
Output
1
Input
16
1 1
1 5
3 5
3 7
2 7
2 9
6 9
6 7
5 7
5 3
4 3
4 4
3 4
3 2
5 2
5 1
1 1
Output
6
Note
The first sample corresponds to the picture:
<image>
The picture shows that you can get in the water under unfortunate circumstances only at turn at the point (1, 1). Thus, the answer is 1. |
n = int(input())
pts = [ tuple(map(int,input().split())) for _ in range(n+1) ]
pts.pop()
def ccw(o,p,q):
return (p[0]-o[0])*(q[1]-o[1])-(p[1]-o[1])*(q[0]-o[0])
s = 0
for i in range(n):
if ccw(pts[i-2],pts[i-1],pts[i])>0:
s += 1
print(s)
# C:\Users\Usuario\HOME2\Programacion\ACM | {
"input": [
"16\n1 1\n1 5\n3 5\n3 7\n2 7\n2 9\n6 9\n6 7\n5 7\n5 3\n4 3\n4 4\n3 4\n3 2\n5 2\n5 1\n1 1\n",
"6\n0 0\n0 1\n1 1\n1 2\n2 2\n2 0\n0 0\n"
],
"output": [
"6\n",
"1\n"
]
} |
2,002 | 7 | After finishing eating her bun, Alyona came up with two integers n and m. She decided to write down two columns of integers β the first column containing integers from 1 to n and the second containing integers from 1 to m. Now the girl wants to count how many pairs of integers she can choose, one from the first column and the other from the second column, such that their sum is divisible by 5.
Formally, Alyona wants to count the number of pairs of integers (x, y) such that 1 β€ x β€ n, 1 β€ y β€ m and <image> equals 0.
As usual, Alyona has some troubles and asks you to help.
Input
The only line of the input contains two integers n and m (1 β€ n, m β€ 1 000 000).
Output
Print the only integer β the number of pairs of integers (x, y) such that 1 β€ x β€ n, 1 β€ y β€ m and (x + y) is divisible by 5.
Examples
Input
6 12
Output
14
Input
11 14
Output
31
Input
1 5
Output
1
Input
3 8
Output
5
Input
5 7
Output
7
Input
21 21
Output
88
Note
Following pairs are suitable in the first sample case:
* for x = 1 fits y equal to 4 or 9;
* for x = 2 fits y equal to 3 or 8;
* for x = 3 fits y equal to 2, 7 or 12;
* for x = 4 fits y equal to 1, 6 or 11;
* for x = 5 fits y equal to 5 or 10;
* for x = 6 fits y equal to 4 or 9.
Only the pair (1, 4) is suitable in the third sample case. | def f(x,y):
return y//5 - (x-1)//5
n, m = map(int, input().split())
s = 0
for i in range(1, n+1):
s += f(1+i, m+i)
print(s)
| {
"input": [
"5 7\n",
"1 5\n",
"21 21\n",
"6 12\n",
"11 14\n",
"3 8\n"
],
"output": [
"7\n",
"1\n",
"88\n",
"14\n",
"31\n",
"5\n"
]
} |
2,003 | 10 | Santa Claus likes palindromes very much. There was his birthday recently. k of his friends came to him to congratulate him, and each of them presented to him a string si having the same length n. We denote the beauty of the i-th string by ai. It can happen that ai is negative β that means that Santa doesn't find this string beautiful at all.
Santa Claus is crazy about palindromes. He is thinking about the following question: what is the maximum possible total beauty of a palindrome which can be obtained by concatenating some (possibly all) of the strings he has? Each present can be used at most once. Note that all strings have the same length n.
Recall that a palindrome is a string that doesn't change after one reverses it.
Since the empty string is a palindrome too, the answer can't be negative. Even if all ai's are negative, Santa can obtain the empty string.
Input
The first line contains two positive integers k and n divided by space and denoting the number of Santa friends and the length of every string they've presented, respectively (1 β€ k, n β€ 100 000; nΒ·k β€ 100 000).
k lines follow. The i-th of them contains the string si and its beauty ai ( - 10 000 β€ ai β€ 10 000). The string consists of n lowercase English letters, and its beauty is integer. Some of strings may coincide. Also, equal strings can have different beauties.
Output
In the only line print the required maximum possible beauty.
Examples
Input
7 3
abb 2
aaa -3
bba -1
zyz -4
abb 5
aaa 7
xyx 4
Output
12
Input
3 1
a 1
a 2
a 3
Output
6
Input
2 5
abcde 10000
abcde 10000
Output
0
Note
In the first example Santa can obtain abbaaaxyxaaabba by concatenating strings 5, 2, 7, 6 and 3 (in this order). | import sys
import math
def solve():
k, n = map(int, input().split())
D = {}
for line in sys.stdin:
s, a = line.split()
if s in D:
D[s].append(int(a))
else:
D[s] = [int(a)]
res = 0
center = 0
for s in D:
revs = s[::-1]
if not revs in D: continue
D[revs].sort()
D[s].sort()
if s == revs:
while len(D[s]) > 1 and D[s][-2] + D[s][-1] > 0:
center = max(center, -D[s][-2])
res += D[s].pop()
res += D[s].pop()
if len(D[s]) > 0:
center = max(center, D[s][-1])
else:
while (len(D[s]) > 0 and len(D[revs]) > 0 and
D[s][-1] + D[revs][-1] > 0):
res += D[s].pop()
res += D[revs].pop()
return res + center
print(solve())
| {
"input": [
"7 3\nabb 2\naaa -3\nbba -1\nzyz -4\nabb 5\naaa 7\nxyx 4\n",
"2 5\nabcde 10000\nabcde 10000\n",
"3 1\na 1\na 2\na 3\n"
],
"output": [
"12\n",
"0\n",
"6\n"
]
} |
2,004 | 9 | A tree is an undirected connected graph without cycles. The distance between two vertices is the number of edges in a simple path between them.
Limak is a little polar bear. He lives in a tree that consists of n vertices, numbered 1 through n.
Limak recently learned how to jump. He can jump from a vertex to any vertex within distance at most k.
For a pair of vertices (s, t) we define f(s, t) as the minimum number of jumps Limak needs to get from s to t. Your task is to find the sum of f(s, t) over all pairs of vertices (s, t) such that s < t.
Input
The first line of the input contains two integers n and k (2 β€ n β€ 200 000, 1 β€ k β€ 5) β the number of vertices in the tree and the maximum allowed jump distance respectively.
The next n - 1 lines describe edges in the tree. The i-th of those lines contains two integers ai and bi (1 β€ ai, bi β€ n) β the indices on vertices connected with i-th edge.
It's guaranteed that the given edges form a tree.
Output
Print one integer, denoting the sum of f(s, t) over all pairs of vertices (s, t) such that s < t.
Examples
Input
6 2
1 2
1 3
2 4
2 5
4 6
Output
20
Input
13 3
1 2
3 2
4 2
5 2
3 6
10 6
6 7
6 13
5 8
5 9
9 11
11 12
Output
114
Input
3 5
2 1
3 1
Output
3
Note
In the first sample, the given tree has 6 vertices and it's displayed on the drawing below. Limak can jump to any vertex within distance at most 2. For example, from the vertex 5 he can jump to any of vertices: 1, 2 and 4 (well, he can also jump to the vertex 5 itself).
<image>
There are <image> pairs of vertices (s, t) such that s < t. For 5 of those pairs Limak would need two jumps: (1, 6), (3, 4), (3, 5), (3, 6), (5, 6). For other 10 pairs one jump is enough. So, the answer is 5Β·2 + 10Β·1 = 20.
In the third sample, Limak can jump between every two vertices directly. There are 3 pairs of vertices (s < t), so the answer is 3Β·1 = 3. | """
#If FastIO not needed, used this and don't forget to strip
#import sys, math
#input = sys.stdin.readline
"""
import os
import sys
from io import BytesIO, IOBase
import heapq as h
from bisect import bisect_left, bisect_right
from types import GeneratorType
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
import os
self.os = os
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
self.os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
from collections import defaultdict as dd, deque as dq, Counter as dc
import math, string
def getInts():
return [int(s) for s in input().split()]
def getInt():
return int(input())
def getStrs():
return [s for s in input().split()]
def getStr():
return input()
def listStr():
return list(input())
def getMat(n):
return [getInts() for _ in range(n)]
MOD = 10**9+7
"""
Each edge goes from parent U to child V
Edge appears on S_V * (N - S_V) paths
For each path of length L, (L + (-L)%K)/K
L%K 0, 1, 2, 3, 4
(K - L%K)%K K K-1 K-2 ...
0 K-1 K-2 ...
"""
def bootstrap(f, stack=[]):
def wrappedfunc(*args, **kwargs):
if stack:
return f(*args, **kwargs)
else:
to = f(*args, **kwargs)
while True:
if type(to) is GeneratorType:
stack.append(to)
to = next(to)
else:
stack.pop()
if not stack:
break
to = stack[-1].send(to)
return to
return wrappedfunc
def solve():
N, K = getInts()
graph = dd(set)
for i in range(N-1):
A, B = getInts()
graph[A].add(B)
graph[B].add(A)
dp_count = [[0 for j in range(5)] for i in range(N+1)]
dp_total = [0 for j in range(N+1)]
global ans
ans = 0
@bootstrap
def dfs(node,parent,depth):
global ans
dp_count[node][depth % K] = 1
dp_total[node] = 1
for neigh in graph[node]:
if neigh != parent:
yield dfs(neigh,node,depth+1)
for i in range(K):
for j in range(K):
diff = (i+j-2*depth)%K
req = (-diff)%K
ans += req * dp_count[node][i] * dp_count[neigh][j]
for i in range(K):
dp_count[node][i] += dp_count[neigh][i]
dp_total[node] += dp_total[neigh]
ans += dp_total[node] * (N - dp_total[node])
yield
dfs(1,-1,0)
return ans//K
print(solve())
| {
"input": [
"6 2\n1 2\n1 3\n2 4\n2 5\n4 6\n",
"3 5\n2 1\n3 1\n",
"13 3\n1 2\n3 2\n4 2\n5 2\n3 6\n10 6\n6 7\n6 13\n5 8\n5 9\n9 11\n11 12\n"
],
"output": [
"20\n",
"3\n",
"114\n"
]
} |
2,005 | 9 | Although Inzane successfully found his beloved bone, Zane, his owner, has yet to return. To search for Zane, he would need a lot of money, of which he sadly has none. To deal with the problem, he has decided to hack the banks.
<image>
There are n banks, numbered from 1 to n. There are also n - 1 wires connecting the banks. All banks are initially online. Each bank also has its initial strength: bank i has initial strength ai.
Let us define some keywords before we proceed. Bank i and bank j are neighboring if and only if there exists a wire directly connecting them. Bank i and bank j are semi-neighboring if and only if there exists an online bank k such that bank i and bank k are neighboring and bank k and bank j are neighboring.
When a bank is hacked, it becomes offline (and no longer online), and other banks that are neighboring or semi-neighboring to it have their strengths increased by 1.
To start his plan, Inzane will choose a bank to hack first. Indeed, the strength of such bank must not exceed the strength of his computer. After this, he will repeatedly choose some bank to hack next until all the banks are hacked, but he can continue to hack bank x if and only if all these conditions are met:
1. Bank x is online. That is, bank x is not hacked yet.
2. Bank x is neighboring to some offline bank.
3. The strength of bank x is less than or equal to the strength of Inzane's computer.
Determine the minimum strength of the computer Inzane needs to hack all the banks.
Input
The first line contains one integer n (1 β€ n β€ 3Β·105) β the total number of banks.
The second line contains n integers a1, a2, ..., an ( - 109 β€ ai β€ 109) β the strengths of the banks.
Each of the next n - 1 lines contains two integers ui and vi (1 β€ ui, vi β€ n, ui β vi) β meaning that there is a wire directly connecting banks ui and vi.
It is guaranteed that the wires connect the banks in such a way that Inzane can somehow hack all the banks using a computer with appropriate strength.
Output
Print one integer β the minimum strength of the computer Inzane needs to accomplish the goal.
Examples
Input
5
1 2 3 4 5
1 2
2 3
3 4
4 5
Output
5
Input
7
38 -29 87 93 39 28 -55
1 2
2 5
3 2
2 4
1 7
7 6
Output
93
Input
5
1 2 7 6 7
1 5
5 3
3 4
2 4
Output
8
Note
In the first sample, Inzane can hack all banks using a computer with strength 5. Here is how:
* Initially, strengths of the banks are [1, 2, 3, 4, 5].
* He hacks bank 5, then strengths of the banks become [1, 2, 4, 5, - ].
* He hacks bank 4, then strengths of the banks become [1, 3, 5, - , - ].
* He hacks bank 3, then strengths of the banks become [2, 4, - , - , - ].
* He hacks bank 2, then strengths of the banks become [3, - , - , - , - ].
* He completes his goal by hacking bank 1.
In the second sample, Inzane can hack banks 4, 2, 3, 1, 5, 7, and 6, in this order. This way, he can hack all banks using a computer with strength 93. | import sys
def solve():
n=int(sys.stdin.readline())
d=list(map(int,sys.stdin.readline().split()))
s=[[] for g in d]
mx_tmp=max(d)
mx_tmp2=max(g for g in d+[-2e9] if g<mx_tmp)
mxpt=[mx_tmp,mx_tmp2]
mxcnt=[d.count(mx_tmp),d.count(mx_tmp2)]
for i in range(1,n):
a,b=map(int,sys.stdin.readline().split())
a-=1;
b-=1;
s[a]+=[b]
s[b]+=[a]
mx=int(2e9)
for i in range(n):
nmx=[]+mxcnt
tmpmax=d[i]
for k in s[i]:
if d[k]==mxpt[0]:
nmx[0]-=1
elif d[k]==mxpt[1]:
nmx[1]-=1
if nmx[0]!=mxcnt[0]:
tmpmax=mxpt[0]+1
elif nmx[1]!=mxcnt[1]:
tmpmax=max(tmpmax,mxpt[1]+1)
if d[i]==mxpt[0]:
nmx[0]-=1
elif d[i]==mxpt[1]:
nmx[1]-=1
if nmx[0]:
tmpmax=mxpt[0]+2
elif nmx[1]:
tmpmax=max(mxpt[1]+2,tmpmax)
mx=min(mx,tmpmax)
print(mx)
if __name__ == '__main__':
solve() | {
"input": [
"5\n1 2 3 4 5\n1 2\n2 3\n3 4\n4 5\n",
"5\n1 2 7 6 7\n1 5\n5 3\n3 4\n2 4\n",
"7\n38 -29 87 93 39 28 -55\n1 2\n2 5\n3 2\n2 4\n1 7\n7 6\n"
],
"output": [
"5\n",
"8\n",
"93\n"
]
} |
2,006 | 10 | Karen has just arrived at school, and she has a math test today!
<image>
The test is about basic addition and subtraction. Unfortunately, the teachers were too busy writing tasks for Codeforces rounds, and had no time to make an actual test. So, they just put one question in the test that is worth all the points.
There are n integers written on a row. Karen must alternately add and subtract each pair of adjacent integers, and write down the sums or differences on the next row. She must repeat this process on the values on the next row, and so on, until only one integer remains. The first operation should be addition.
Note that, if she ended the previous row by adding the integers, she should start the next row by subtracting, and vice versa.
The teachers will simply look at the last integer, and then if it is correct, Karen gets a perfect score, otherwise, she gets a zero for the test.
Karen has studied well for this test, but she is scared that she might make a mistake somewhere and it will cause her final answer to be wrong. If the process is followed, what number can she expect to be written on the last row?
Since this number can be quite large, output only the non-negative remainder after dividing it by 109 + 7.
Input
The first line of input contains a single integer n (1 β€ n β€ 200000), the number of numbers written on the first row.
The next line contains n integers. Specifically, the i-th one among these is ai (1 β€ ai β€ 109), the i-th number on the first row.
Output
Output a single integer on a line by itself, the number on the final row after performing the process above.
Since this number can be quite large, print only the non-negative remainder after dividing it by 109 + 7.
Examples
Input
5
3 6 9 12 15
Output
36
Input
4
3 7 5 2
Output
1000000006
Note
In the first test case, the numbers written on the first row are 3, 6, 9, 12 and 15.
Karen performs the operations as follows:
<image>
The non-negative remainder after dividing the final number by 109 + 7 is still 36, so this is the correct output.
In the second test case, the numbers written on the first row are 3, 7, 5 and 2.
Karen performs the operations as follows:
<image>
The non-negative remainder after dividing the final number by 109 + 7 is 109 + 6, so this is the correct output. | n = int(input())
p = list(map(int,input().split()))
MOD = 10**9+7
mode = 0
if n%4 == 3:
n-= 1
new = []
for i in range(n):
if mode == 0: new.append(p[i]+p[i+1])
else: new.append(p[i]-p[i+1])
mode = 1-mode
p = new
def calc0(p):
res = 0
ncr = 1
n = len(p)//2-1
for i in range(n+1):
res = (res+ncr*(p[i*2]-p[i*2+1])) % MOD
ncr = (ncr*(n-i)*pow(i+1,MOD-2,MOD)) % MOD
return res
def calc1(p):
res = 0
ncr = 1
n = len(p)//2
for i in range(n+1):
res = (res+ncr*(p[i*2])) % MOD
ncr = (ncr*(n-i)*pow(i+1,MOD-2,MOD)) % MOD
return res
def calc2(p):
res = 0
ncr = 1
n = len(p)//2-1
for i in range(n+1):
res = (res+ncr*(p[i*2]+p[i*2+1])) % MOD
ncr = (ncr*(n-i)*pow(i+1,MOD-2,MOD)) % MOD
return res
print([calc0,calc1,calc2,-1][n%4](p)) | {
"input": [
"4\n3 7 5 2\n",
"5\n3 6 9 12 15\n"
],
"output": [
"1000000006",
"36"
]
} |
2,007 | 10 | Leha plays a computer game, where is on each level is given a connected graph with n vertices and m edges. Graph can contain multiple edges, but can not contain self loops. Each vertex has an integer di, which can be equal to 0, 1 or - 1. To pass the level, he needs to find a Β«goodΒ» subset of edges of the graph or say, that it doesn't exist. Subset is called Β«goodΒ», if by by leaving only edges from this subset in the original graph, we obtain the following: for every vertex i, di = - 1 or it's degree modulo 2 is equal to di. Leha wants to pass the game as soon as possible and ask you to help him. In case of multiple correct answers, print any of them.
Input
The first line contains two integers n, m (1 β€ n β€ 3Β·105, n - 1 β€ m β€ 3Β·105) β number of vertices and edges.
The second line contains n integers d1, d2, ..., dn ( - 1 β€ di β€ 1) β numbers on the vertices.
Each of the next m lines contains two integers u and v (1 β€ u, v β€ n) β edges. It's guaranteed, that graph in the input is connected.
Output
Print - 1 in a single line, if solution doesn't exist. Otherwise in the first line k β number of edges in a subset. In the next k lines indexes of edges. Edges are numerated in order as they are given in the input, starting from 1.
Examples
Input
1 0
1
Output
-1
Input
4 5
0 0 0 -1
1 2
2 3
3 4
1 4
2 4
Output
0
Input
2 1
1 1
1 2
Output
1
1
Input
3 3
0 -1 1
1 2
2 3
1 3
Output
1
2
Note
In the first sample we have single vertex without edges. It's degree is 0 and we can not get 1. | import os,io
input=io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
import sys
import heapq
INF=10**9
def Dijkstra(graph, start,m):
dist=[INF]*len(graph)
parent=[INF]*len(graph)
queue=[(0, start)]
while queue:
path_len, v=heapq.heappop(queue)
if dist[v]==INF:
dist[v]=path_len
for w in graph[v]:
if dist[w[0]]==INF:
parent[w[0]]=[v,w[1]]
heapq.heappush(queue, (dist[v]+1, w[0]))
return (dist,parent)
n,m=map(int,input().split())
d=list(map(int,input().split()))
graph=[]
for i in range(n):
graph.append([])
for i in range(m):
u,v=map(int,input().split())
graph[u-1].append([v-1,i])
graph[v-1].append([u-1,i])
count=0
flag=0
for i in range(n):
if d[i]==1:
count+=1
elif d[i]==-1:
flag=1
if count%2==1 and flag==0:
print(-1)
sys.exit()
if count%2==1:
for i in range(n):
if d[i]==-1 and flag==1:
d[i]=1
flag=0
elif d[i]==-1:
d[i]=0
else:
for i in range(n):
if d[i]==-1:
d[i]=0
dist,parent=Dijkstra(graph,0,m)
actualused=[0]*m
children=[0]*n
actualchildren=[0]*n
for i in range(1,n):
children[parent[i][0]]+=1
stack=[]
for i in range(n):
if children[i]==actualchildren[i]:
stack.append(i)
while stack:
curr=stack.pop()
if curr==0:
break
p=parent[curr]
k=p[0]
if d[curr]==1:
actualused[p[1]]=1
d[k]=1-d[k]
actualchildren[k]+=1
if actualchildren[k]==children[k]:
stack.append(k)
ans=[]
for i in range(m):
if actualused[i]:
ans.append(str(i+1))
print(len(ans))
print(' '.join(ans)) | {
"input": [
"1 0\n1\n",
"3 3\n0 -1 1\n1 2\n2 3\n1 3\n",
"2 1\n1 1\n1 2\n",
"4 5\n0 0 0 -1\n1 2\n2 3\n3 4\n1 4\n2 4\n"
],
"output": [
"-1\n",
"1\n2\n",
"1\n1\n",
"0\n"
]
} |
2,008 | 11 | Dr. Evil is interested in math and functions, so he gave Mahmoud and Ehab array a of length n and array b of length m. He introduced a function f(j) which is defined for integers j, which satisfy 0 β€ j β€ m - n. Suppose, ci = ai - bi + j. Then f(j) = |c1 - c2 + c3 - c4... cn|. More formally, <image>.
Dr. Evil wants Mahmoud and Ehab to calculate the minimum value of this function over all valid j. They found it a bit easy, so Dr. Evil made their task harder. He will give them q update queries. During each update they should add an integer xi to all elements in a in range [li;ri] i.e. they should add xi to ali, ali + 1, ... , ari and then they should calculate the minimum value of f(j) for all valid j.
Please help Mahmoud and Ehab.
Input
The first line contains three integers n, m and q (1 β€ n β€ m β€ 105, 1 β€ q β€ 105) β number of elements in a, number of elements in b and number of queries, respectively.
The second line contains n integers a1, a2, ..., an. ( - 109 β€ ai β€ 109) β elements of a.
The third line contains m integers b1, b2, ..., bm. ( - 109 β€ bi β€ 109) β elements of b.
Then q lines follow describing the queries. Each of them contains three integers li ri xi (1 β€ li β€ ri β€ n, - 109 β€ x β€ 109) β range to be updated and added value.
Output
The first line should contain the minimum value of the function f before any update.
Then output q lines, the i-th of them should contain the minimum value of the function f after performing the i-th update .
Example
Input
5 6 3
1 2 3 4 5
1 2 3 4 5 6
1 1 10
1 1 -9
1 5 -1
Output
0
9
0
0
Note
For the first example before any updates it's optimal to choose j = 0, f(0) = |(1 - 1) - (2 - 2) + (3 - 3) - (4 - 4) + (5 - 5)| = |0| = 0.
After the first update a becomes {11, 2, 3, 4, 5} and it's optimal to choose j = 1, f(1) = |(11 - 2) - (2 - 3) + (3 - 4) - (4 - 5) + (5 - 6) = |9| = 9.
After the second update a becomes {2, 2, 3, 4, 5} and it's optimal to choose j = 1, f(1) = |(2 - 2) - (2 - 3) + (3 - 4) - (4 - 5) + (5 - 6)| = |0| = 0.
After the third update a becomes {1, 1, 2, 3, 4} and it's optimal to choose j = 0, f(0) = |(1 - 1) - (1 - 2) + (2 - 3) - (3 - 4) + (4 - 5)| = |0| = 0. | from bisect import *
f = lambda: list(map(int, input().split()))
n, m, q = f()
k = m - n + 1
a = f()
s = sum(a[0:n:2]) - sum(a[1:n:2])
b = [0] + f()
for i in range(2, m + 1, 2): b[i] = -b[i]
for i in range(m): b[i + 1] += b[i]
u = [b[j] - b[j + n] for j in range(1, k, 2)]
v = [b[j + n] - b[j] for j in range(0, k, 2)]
d = sorted(u + v)
def g(s):
j = bisect_right(d, s)
print(min(abs(s - d[j % k]), abs(s - d[j - 1])))
g(s)
for i in range(q):
l, r, x = f()
s += x * (r % 2 + l % 2 - 1)
g(s) | {
"input": [
"5 6 3\n1 2 3 4 5\n1 2 3 4 5 6\n1 1 10\n1 1 -9\n1 5 -1\n"
],
"output": [
"0\n9\n0\n0\n"
]
} |
2,009 | 9 | You are given a string s consisting of lowercase Latin letters. Character c is called k-dominant iff each substring of s with length at least k contains this character c.
You have to find minimum k such that there exists at least one k-dominant character.
Input
The first line contains string s consisting of lowercase Latin letters (1 β€ |s| β€ 100000).
Output
Print one number β the minimum value of k such that there exists at least one k-dominant character.
Examples
Input
abacaba
Output
2
Input
zzzzz
Output
1
Input
abcde
Output
3 | i=input()
s=set(i)
def F(c):
l=[i+1 for i,x in enumerate(i) if x==c]
d=(y-x for x,y in zip(l,l[1:]))
return max(l[0],len(i)-l[-1]+1,*d)
print(min(map(F,s))) | {
"input": [
"zzzzz\n",
"abacaba\n",
"abcde\n"
],
"output": [
"1",
"2",
"3"
]
} |
2,010 | 7 | You are given an array of n integer numbers a0, a1, ..., an - 1. Find the distance between two closest (nearest) minimums in it. It is guaranteed that in the array a minimum occurs at least two times.
Input
The first line contains positive integer n (2 β€ n β€ 105) β size of the given array. The second line contains n integers a0, a1, ..., an - 1 (1 β€ ai β€ 109) β elements of the array. It is guaranteed that in the array a minimum occurs at least two times.
Output
Print the only number β distance between two nearest minimums in the array.
Examples
Input
2
3 3
Output
1
Input
3
5 6 5
Output
2
Input
9
2 1 3 5 4 1 2 3 1
Output
3 | def main():
n = int(input())
a = list(map(int, input().split()))
m = min(a)
xs = [i for i, x in enumerate(a) if x == m]
ans = min(b - a for a, b in zip(xs, xs[1:]))
print(ans)
main()
| {
"input": [
"2\n3 3\n",
"9\n2 1 3 5 4 1 2 3 1\n",
"3\n5 6 5\n"
],
"output": [
"1\n",
"3\n",
"2\n"
]
} |
2,011 | 7 | Petya loves hockey very much. One day, as he was watching a hockey match, he fell asleep. Petya dreamt of being appointed to change a hockey team's name. Thus, Petya was given the original team name w and the collection of forbidden substrings s1, s2, ..., sn. All those strings consist of uppercase and lowercase Latin letters. String w has the length of |w|, its characters are numbered from 1 to |w|.
First Petya should find all the occurrences of forbidden substrings in the w string. During the search of substrings the case of letter shouldn't be taken into consideration. That is, strings "aBC" and "ABc" are considered equal.
After that Petya should perform the replacement of all letters covered by the occurrences. More formally: a letter in the position i should be replaced by any other one if for position i in string w there exist pair of indices l, r (1 β€ l β€ i β€ r β€ |w|) such that substring w[l ... r] is contained in the collection s1, s2, ..., sn, when using case insensitive comparison. During the replacement the letter's case should remain the same. Petya is not allowed to replace the letters that aren't covered by any forbidden substring.
Letter letter (uppercase or lowercase) is considered lucky for the hockey players. That's why Petya should perform the changes so that the letter occurred in the resulting string as many times as possible. Help Petya to find such resulting string. If there are several such strings, find the one that comes first lexicographically.
Note that the process of replacements is not repeated, it occurs only once. That is, if after Petya's replacements the string started to contain new occurrences of bad substrings, Petya pays no attention to them.
Input
The first line contains the only integer n (1 β€ n β€ 100) β the number of forbidden substrings in the collection. Next n lines contain these substrings. The next line contains string w. All those n + 1 lines are non-empty strings consisting of uppercase and lowercase Latin letters whose length does not exceed 100. The last line contains a lowercase letter letter.
Output
Output the only line β Petya's resulting string with the maximum number of letters letter. If there are several answers then output the one that comes first lexicographically.
The lexicographical comparison is performed by the standard < operator in modern programming languages. The line a is lexicographically smaller than the line b, if a is a prefix of b, or there exists such an i (1 β€ i β€ |a|), that ai < bi, and for any j (1 β€ j < i) aj = bj. |a| stands for the length of string a.
Examples
Input
3
bers
ucky
elu
PetrLoveLuckyNumbers
t
Output
PetrLovtTttttNumtttt
Input
4
hello
party
abefglghjdhfgj
IVan
petrsmatchwin
a
Output
petrsmatchwin
Input
2
aCa
cba
abAcaba
c
Output
abCacba | import sys
from math import *
def minp():
return sys.stdin.readline().strip()
def mint():
return int(minp())
def mints():
return map(int, minp().split())
def same(a, b):
return a.lower() == b.lower()
n = mint()
w = []
for i in range(n):
w.append(minp().lower())
s = minp()
g = [False]*len(s)
c = minp()
for i in w:
for j in range(len(s)-len(i)+1):
if s[j:j+len(i)].lower() == i:
for k in range(len(i)):
g[j+k] = True
r = ''
for i in range(len(s)):
if g[i]:
x = s[i]
if x == c.lower():
if c.lower() == 'a':
r += 'b'
else:
r += 'a'
elif x == c.upper():
if c.lower() == 'a':
r += 'B'
else:
r += 'A'
elif x.islower():
r += c.lower()
else:
r += c.upper()
else:
r += s[i]
print(r) | {
"input": [
"2\naCa\ncba\nabAcaba\nc\n",
"3\nbers\nucky\nelu\nPetrLoveLuckyNumbers\nt\n",
"4\nhello\nparty\nabefglghjdhfgj\nIVan\npetrsmatchwin\na\n"
],
"output": [
"abCacba\n",
"PetrLovtTttttNumtttt\n",
"petrsmatchwin\n"
]
} |
2,012 | 10 | Polycarp likes numbers that are divisible by 3.
He has a huge number s. Polycarp wants to cut from it the maximum number of numbers that are divisible by 3. To do this, he makes an arbitrary number of vertical cuts between pairs of adjacent digits. As a result, after m such cuts, there will be m+1 parts in total. Polycarp analyzes each of the obtained numbers and finds the number of those that are divisible by 3.
For example, if the original number is s=3121, then Polycarp can cut it into three parts with two cuts: 3|1|21. As a result, he will get two numbers that are divisible by 3.
Polycarp can make an arbitrary number of vertical cuts, where each cut is made between a pair of adjacent digits. The resulting numbers cannot contain extra leading zeroes (that is, the number can begin with 0 if and only if this number is exactly one character '0'). For example, 007, 01 and 00099 are not valid numbers, but 90, 0 and 10001 are valid.
What is the maximum number of numbers divisible by 3 that Polycarp can obtain?
Input
The first line of the input contains a positive integer s. The number of digits of the number s is between 1 and 2β
10^5, inclusive. The first (leftmost) digit is not equal to 0.
Output
Print the maximum number of numbers divisible by 3 that Polycarp can get by making vertical cuts in the given number s.
Examples
Input
3121
Output
2
Input
6
Output
1
Input
1000000000000000000000000000000000
Output
33
Input
201920181
Output
4
Note
In the first example, an example set of optimal cuts on the number is 3|1|21.
In the second example, you do not need to make any cuts. The specified number 6 forms one number that is divisible by 3.
In the third example, cuts must be made between each pair of digits. As a result, Polycarp gets one digit 1 and 33 digits 0. Each of the 33 digits 0 forms a number that is divisible by 3.
In the fourth example, an example set of optimal cuts is 2|0|1|9|201|81. The numbers 0, 9, 201 and 81 are divisible by 3. | def main():
s=list(map(int,list(input())))
cnt=0
add=0
cnt_to_3=0
for i in range(len(s)):
add+=s[i]
cnt_to_3+=1
if s[i]%3==0 or add%3==0 or cnt_to_3==3:
cnt+=1
add=0
cnt_to_3=0
print(cnt)
main() | {
"input": [
"201920181\n",
"3121\n",
"1000000000000000000000000000000000\n",
"6\n"
],
"output": [
"4\n",
"2\n",
"33\n",
"1\n"
]
} |
2,013 | 8 | You are given a problemset consisting of n problems. The difficulty of the i-th problem is a_i. It is guaranteed that all difficulties are distinct and are given in the increasing order.
You have to assemble the contest which consists of some problems of the given problemset. In other words, the contest you have to assemble should be a subset of problems (not necessary consecutive) of the given problemset. There is only one condition that should be satisfied: for each problem but the hardest one (the problem with the maximum difficulty) there should be a problem with the difficulty greater than the difficulty of this problem but not greater than twice the difficulty of this problem. In other words, let a_{i_1}, a_{i_2}, ..., a_{i_p} be the difficulties of the selected problems in increasing order. Then for each j from 1 to p-1 a_{i_{j + 1}} β€ a_{i_j} β
2 should hold. It means that the contest consisting of only one problem is always valid.
Among all contests satisfying the condition above you have to assemble one with the maximum number of problems. Your task is to find this number of problems.
Input
The first line of the input contains one integer n (1 β€ n β€ 2 β
10^5) β the number of problems in the problemset.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 β€ a_i β€ 10^9) β difficulties of the problems. It is guaranteed that difficulties of the problems are distinct and are given in the increasing order.
Output
Print a single integer β maximum number of problems in the contest satisfying the condition in the problem statement.
Examples
Input
10
1 2 5 6 7 10 21 23 24 49
Output
4
Input
5
2 10 50 110 250
Output
1
Input
6
4 7 12 100 150 199
Output
3
Note
Description of the first example: there are 10 valid contests consisting of 1 problem, 10 valid contests consisting of 2 problems ([1, 2], [5, 6], [5, 7], [5, 10], [6, 7], [6, 10], [7, 10], [21, 23], [21, 24], [23, 24]), 5 valid contests consisting of 3 problems ([5, 6, 7], [5, 6, 10], [5, 7, 10], [6, 7, 10], [21, 23, 24]) and a single valid contest consisting of 4 problems ([5, 6, 7, 10]).
In the second example all the valid contests consist of 1 problem.
In the third example are two contests consisting of 3 problems: [4, 7, 12] and [100, 150, 199]. | def mi():
return map(int, input().split())
n = int(input())
a = list(mi())
c = 1
maxc = 1
for i in range(1,n):
if a[i]/a[i-1]<=2:
c+=1
else:
c = 1
maxc = max(c,maxc)
print (maxc) | {
"input": [
"5\n2 10 50 110 250\n",
"10\n1 2 5 6 7 10 21 23 24 49\n",
"6\n4 7 12 100 150 199\n"
],
"output": [
"1\n",
"4\n",
"3\n"
]
} |
2,014 | 7 | One rainy gloomy evening when all modules hid in the nearby cafes to drink hot energetic cocktails, the Hexadecimal virus decided to fly over the Mainframe to look for a Great Idea. And she has found one!
Why not make her own Codeforces, with blackjack and other really cool stuff? Many people will surely be willing to visit this splendid shrine of high culture.
In Mainframe a standard pack of 52 cards is used to play blackjack. The pack contains cards of 13 values: 2, 3, 4, 5, 6, 7, 8, 9, 10, jacks, queens, kings and aces. Each value also exists in one of four suits: hearts, diamonds, clubs and spades. Also, each card earns some value in points assigned to it: cards with value from two to ten earn from 2 to 10 points, correspondingly. An ace can either earn 1 or 11, whatever the player wishes. The picture cards (king, queen and jack) earn 10 points. The number of points a card earns does not depend on the suit. The rules of the game are very simple. The player gets two cards, if the sum of points of those cards equals n, then the player wins, otherwise the player loses.
The player has already got the first card, it's the queen of spades. To evaluate chances for victory, you should determine how many ways there are to get the second card so that the sum of points exactly equals n.
Input
The only line contains n (1 β€ n β€ 25) β the required sum of points.
Output
Print the numbers of ways to get the second card in the required way if the first card is the queen of spades.
Examples
Input
12
Output
4
Input
20
Output
15
Input
10
Output
0
Note
In the first sample only four two's of different suits can earn the required sum of points.
In the second sample we can use all tens, jacks, queens and kings; overall it's 15 cards, as the queen of spades (as any other card) is only present once in the pack of cards and it's already in use.
In the third sample there is no card, that would add a zero to the current ten points. | # Author: ΟΞ±
def out(n):
if n < 1 or n > 11:
return 0
if n == 10:
return 15
return 4
print(out(int(input()) - 10)) | {
"input": [
"12\n",
"10\n",
"20\n"
],
"output": [
"4\n",
"0\n",
"15\n"
]
} |
2,015 | 8 | You are given a matrix of size n Γ n filled with lowercase English letters. You can change no more than k letters in this matrix.
Consider all paths from the upper left corner to the lower right corner that move from a cell to its neighboring cell to the right or down. Each path is associated with the string that is formed by all the letters in the cells the path visits. Thus, the length of each string is 2n - 1.
Find the lexicographically smallest string that can be associated with a path after changing letters in at most k cells of the matrix.
A string a is lexicographically smaller than a string b, if the first different letter in a and b is smaller in a.
Input
The first line contains two integers n and k (1 β€ n β€ 2000, 0 β€ k β€ n^2) β the size of the matrix and the number of letters you can change.
Each of the next n lines contains a string of n lowercase English letters denoting one row of the matrix.
Output
Output the lexicographically smallest string that can be associated with some valid path after changing no more than k letters in the matrix.
Examples
Input
4 2
abcd
bcde
bcad
bcde
Output
aaabcde
Input
5 3
bwwwz
hrhdh
sepsp
sqfaf
ajbvw
Output
aaaepfafw
Input
7 6
ypnxnnp
pnxonpm
nxanpou
xnnpmud
nhtdudu
npmuduh
pmutsnz
Output
aaaaaaadudsnz
Note
In the first sample test case it is possible to change letters 'b' in cells (2, 1) and (3, 1) to 'a', then the minimum path contains cells (1, 1), (2, 1), (3, 1), (4, 1), (4, 2), (4, 3), (4, 4). The first coordinate corresponds to the row and the second coordinate corresponds to the column. | def solve(m, matrix, good, n):
c = 'z'
for x in range(n):
y = m - x
if y < 0 or y >= n: continue
if not good[x][y]: continue
if x < n - 1: c = min(c, matrix[x + 1][y])
if y < n - 1: c = min(c, matrix[x][y + 1])
for x in range(n):
y = m - x
if y < 0 or y >= n: continue
if not good[x][y]: continue
if x < n - 1 and matrix[x + 1][y] == c: good[x+1][y] = 1
if y < n - 1 and matrix[x][y + 1] == c: good[x][y + 1] = 1
return c
def main():
n, k = map(int, input().split())
matrix = []
for i in range(n):
s = list(input())
matrix.append(s)
dp = [[0 for i in range(n)] for j in range(n)]
good = [[0 for i in range(n)] for j in range(n)]
dp[0][0] = 0 if matrix[0][0] == 'a' else 1
for i in range(1, n):
dp[0][i] = dp[0][i - 1]
if matrix[0][i] != 'a':
dp[0][i] += 1
dp[i][0] = dp[i - 1][0]
if matrix[i][0] != 'a':
dp[i][0] += 1
for i in range(1, n):
for j in range(1, n):
dp[i][j] = min(dp[i-1][j], dp[i][j-1])
if matrix[i][j] != 'a':
dp[i][j] += 1
m = -1
for i in range(n):
for j in range(n):
if dp[i][j] <= k:
m = max(m, i + j)
if m == -1:
print(matrix[0][0], end = '')
m = 0
good[0][0] = 1
else:
for i in range(m + 1):
print('a', end = '')
for i in range(n):
y = m - i
if y < 0 or y >= n:
continue
if dp[i][y] <= k:
good[i][y] = 1
while m < 2*n - 2:
res = solve(m, matrix, good, n)
print(res, end = '')
m += 1
if __name__=="__main__":
main() | {
"input": [
"4 2\nabcd\nbcde\nbcad\nbcde\n",
"7 6\nypnxnnp\npnxonpm\nnxanpou\nxnnpmud\nnhtdudu\nnpmuduh\npmutsnz\n",
"5 3\nbwwwz\nhrhdh\nsepsp\nsqfaf\najbvw\n"
],
"output": [
"aaabcde\n",
"aaaaaaadudsnz\n",
"aaaepfafw\n"
]
} |
2,016 | 10 | You are given an undirected unweighted graph consisting of n vertices and m edges.
You have to write a number on each vertex of the graph. Each number should be 1, 2 or 3. The graph becomes beautiful if for each edge the sum of numbers on vertices connected by this edge is odd.
Calculate the number of possible ways to write numbers 1, 2 and 3 on vertices so the graph becomes beautiful. Since this number may be large, print it modulo 998244353.
Note that you have to write exactly one number on each vertex.
The graph does not have any self-loops or multiple edges.
Input
The first line contains one integer t (1 β€ t β€ 3 β
10^5) β the number of tests in the input.
The first line of each test contains two integers n and m (1 β€ n β€ 3 β
10^5, 0 β€ m β€ 3 β
10^5) β the number of vertices and the number of edges, respectively. Next m lines describe edges: i-th line contains two integers u_i, v_i (1 β€ u_i, v_i β€ n; u_i β v_i) β indices of vertices connected by i-th edge.
It is guaranteed that β_{i=1}^{t} n β€ 3 β
10^5 and β_{i=1}^{t} m β€ 3 β
10^5.
Output
For each test print one line, containing one integer β the number of possible ways to write numbers 1, 2, 3 on the vertices of given graph so it becomes beautiful. Since answers may be large, print them modulo 998244353.
Example
Input
2
2 1
1 2
4 6
1 2
1 3
1 4
2 3
2 4
3 4
Output
4
0
Note
Possible ways to distribute numbers in the first test:
1. the vertex 1 should contain 1, and 2 should contain 2;
2. the vertex 1 should contain 3, and 2 should contain 2;
3. the vertex 1 should contain 2, and 2 should contain 1;
4. the vertex 1 should contain 2, and 2 should contain 3.
In the second test there is no way to distribute numbers. |
M=998244353
t=int(input())
n,m=0,0
g=[]
v=[]
def dfs(r):
s=[r]
v[r]=1
c=[0,1]
while s:
x=s.pop()
for j in g[x]:
if v[j]==v[x]:return 0
if v[j]==-1:
v[j]=v[x]^1
c[v[j]]+=1
s.append(j)
if c[0]==0 or c[1]==0:return 3
return ((2**c[0])%M + (2**c[1])%M)%M
o=[]
for i in range(t):
n,m=map(int,input().split())
g=[[]for _ in range(n)]
for _ in range(m):
a,b=map(int,input().split())
g[a-1].append(b-1)
g[b-1].append(a-1)
v=[-1]*n
ox=1
for j in range(n):
if v[j]==-1:
ox=(ox*dfs(j))%M
o.append(ox)
print('\n'.join(map(str,o))) | {
"input": [
"2\n2 1\n1 2\n4 6\n1 2\n1 3\n1 4\n2 3\n2 4\n3 4\n"
],
"output": [
"4\n0\n"
]
} |
2,017 | 10 | Reading books is one of Sasha's passions. Once while he was reading one book, he became acquainted with an unusual character. The character told about himself like that: "Many are my names in many countries. Mithrandir among the Elves, TharkΓ»n to the Dwarves, OlΓ³rin I was in my youth in the West that is forgotten, in the South IncΓ‘nus, in the North Gandalf; to the East I go not."
And at that moment Sasha thought, how would that character be called in the East? In the East all names are palindromes. A string is a palindrome if it reads the same backward as forward. For example, such strings as "kazak", "oo" and "r" are palindromes, but strings "abb" and "ij" are not.
Sasha believed that the hero would be named after one of the gods of the East. As long as there couldn't be two equal names, so in the East people did the following: they wrote the original name as a string on a piece of paper, then cut the paper minimum number of times k, so they got k+1 pieces of paper with substrings of the initial string, and then unite those pieces together to get a new string. Pieces couldn't be turned over, they could be shuffled.
In this way, it's possible to achive a string abcdefg from the string f|de|abc|g using 3 cuts (by swapping papers with substrings f and abc). The string cbadefg can't be received using the same cuts.
More formally, Sasha wants for the given palindrome s find such minimum k, that you can cut this string into k + 1 parts, and then unite them in such a way that the final string will be a palindrome and it won't be equal to the initial string s. It there is no answer, then print "Impossible" (without quotes).
Input
The first line contains one string s (1 β€ |s| β€ 5 000) β the initial name, which consists only of lowercase Latin letters. It is guaranteed that s is a palindrome.
Output
Print one integer k β the minimum number of cuts needed to get a new name, or "Impossible" (without quotes).
Examples
Input
nolon
Output
2
Input
otto
Output
1
Input
qqqq
Output
Impossible
Input
kinnikkinnik
Output
1
Note
In the first example, you can cut the string in those positions: no|l|on, and then unite them as follows on|l|no. It can be shown that there is no solution with one cut.
In the second example, you can cut the string right in the middle, and swap peaces, so you get toot.
In the third example, you can't make a string, that won't be equal to the initial one.
In the fourth example, you can cut the suffix nik and add it to the beginning, so you get nikkinnikkin. | from sys import *
s = input();
def check(t):
return (t == t[::-1]) and (t != s)
for i in range(1, len(s)):
t = s[i:] + s[:i]
if check(t):
print("1")
exit()
for i in range(1, len(s)//2 + (len(s)%2)):
t = s[-i:] + s[i:-i] + s[:i]
if check(t):
print("2")
exit()
print("Impossible") | {
"input": [
"nolon\n",
"kinnikkinnik\n",
"otto\n",
"qqqq\n"
],
"output": [
"2\n",
"1\n",
"1\n",
"Impossible\n"
]
} |
2,018 | 12 | This problem is given in two editions, which differ exclusively in the constraints on the number n.
You are given an array of integers a[1], a[2], ..., a[n]. A block is a sequence of contiguous (consecutive) elements a[l], a[l+1], ..., a[r] (1 β€ l β€ r β€ n). Thus, a block is defined by a pair of indices (l, r).
Find a set of blocks (l_1, r_1), (l_2, r_2), ..., (l_k, r_k) such that:
* They do not intersect (i.e. they are disjoint). Formally, for each pair of blocks (l_i, r_i) and (l_j, r_j) where i β j either r_i < l_j or r_j < l_i.
* For each block the sum of its elements is the same. Formally, $$$a[l_1]+a[l_1+1]+...+a[r_1]=a[l_2]+a[l_2+1]+...+a[r_2]= ... = a[l_k]+a[l_k+1]+...+a[r_k].$$$
* The number of the blocks in the set is maximum. Formally, there does not exist a set of blocks (l_1', r_1'), (l_2', r_2'), ..., (l_{k'}', r_{k'}') satisfying the above two requirements with k' > k.
<image> The picture corresponds to the first example. Blue boxes illustrate blocks.
Write a program to find such a set of blocks.
Input
The first line contains integer n (1 β€ n β€ 1500) β the length of the given array. The second line contains the sequence of elements a[1], a[2], ..., a[n] (-10^5 β€ a_i β€ 10^5).
Output
In the first line print the integer k (1 β€ k β€ n). The following k lines should contain blocks, one per line. In each line print a pair of indices l_i, r_i (1 β€ l_i β€ r_i β€ n) β the bounds of the i-th block. You can print blocks in any order. If there are multiple answers, print any of them.
Examples
Input
7
4 1 2 2 1 5 3
Output
3
7 7
2 3
4 5
Input
11
-5 -4 -3 -2 -1 0 1 2 3 4 5
Output
2
3 4
1 1
Input
4
1 1 1 1
Output
4
4 4
1 1
2 2
3 3 | from itertools import accumulate
def main():
n = int(input())
arr = list(map(int, input().split()))
arr_sums = [0] + list(accumulate(arr))
blocks = {}
for i in range(1, n+1):
for j in range(i):
total = arr_sums[i] - arr_sums[j]
if total not in blocks:
blocks[total] = [(j+1, i)]
else:
if blocks[total][-1][1] < j+1:
blocks[total].append((j+1, i))
max_block = sorted([(i, len(x)) for i, x in blocks.items()], key=lambda y: (-y[1], y[0]))
print(max_block[0][1])
for item in blocks[max_block[0][0]]:
print(item[0], item[1])
if __name__ == '__main__':
main()
| {
"input": [
"7\n4 1 2 2 1 5 3\n",
"4\n1 1 1 1\n",
"11\n-5 -4 -3 -2 -1 0 1 2 3 4 5\n"
],
"output": [
"3\n2 3\n4 5\n7 7\n",
"4\n1 1\n2 2\n3 3\n4 4\n",
"2\n1 1\n3 4\n"
]
} |
2,019 | 7 | You are planning to build housing on a street. There are n spots available on the street on which you can build a house. The spots are labeled from 1 to n from left to right. In each spot, you can build a house with an integer height between 0 and h.
In each spot, if a house has height a, you will gain a^2 dollars from it.
The city has m zoning restrictions. The i-th restriction says that the tallest house from spots l_i to r_i (inclusive) must be at most x_i.
You would like to build houses to maximize your profit. Determine the maximum profit possible.
Input
The first line contains three integers n, h, and m (1 β€ n,h,m β€ 50) β the number of spots, the maximum height, and the number of restrictions.
Each of the next m lines contains three integers l_i, r_i, and x_i (1 β€ l_i β€ r_i β€ n, 0 β€ x_i β€ h) β left and right limits (inclusive) of the i-th restriction and the maximum possible height in that range.
Output
Print a single integer, the maximum profit you can make.
Examples
Input
3 3 3
1 1 1
2 2 3
3 3 2
Output
14
Input
4 10 2
2 3 8
3 4 7
Output
262
Note
In the first example, there are 3 houses, the maximum height of a house is 3, and there are 3 restrictions. The first restriction says the tallest house between 1 and 1 must be at most 1. The second restriction says the tallest house between 2 and 2 must be at most 3. The third restriction says the tallest house between 3 and 3 must be at most 2.
In this case, it is optimal to build houses with heights [1, 3, 2]. This fits within all the restrictions. The total profit in this case is 1^2 + 3^2 + 2^2 = 14.
In the second example, there are 4 houses, the maximum height of a house is 10, and there are 2 restrictions. The first restriction says the tallest house from 2 to 3 must be at most 8. The second restriction says the tallest house from 3 to 4 must be at most 7.
In this case, it's optimal to build houses with heights [10, 8, 7, 7]. We get a profit of 10^2+8^2+7^2+7^2 = 262. Note that there are two restrictions on house 3 and both of them must be satisfied. Also, note that even though there isn't any explicit restrictions on house 1, we must still limit its height to be at most 10 (h=10). | def main():
n,h,m=map(int,input().split())
h=[h]*(n+1)
for i in range(m):
l,r,mh=list(map(int,input().split()))
for j in range(l,r+1):
h[j]=min(h[j],mh)
s=0
for i in h[1:]:
s+=i**2
print(s)
main() | {
"input": [
"3 3 3\n1 1 1\n2 2 3\n3 3 2\n",
"4 10 2\n2 3 8\n3 4 7\n"
],
"output": [
"14\n",
"262\n"
]
} |
2,020 | 7 | Amugae has a hotel consisting of 10 rooms. The rooms are numbered from 0 to 9 from left to right.
The hotel has two entrances β one from the left end, and another from the right end. When a customer arrives to the hotel through the left entrance, they are assigned to an empty room closest to the left entrance. Similarly, when a customer arrives at the hotel through the right entrance, they are assigned to an empty room closest to the right entrance.
One day, Amugae lost the room assignment list. Thankfully Amugae's memory is perfect, and he remembers all of the customers: when a customer arrived, from which entrance, and when they left the hotel. Initially the hotel was empty. Write a program that recovers the room assignment list from Amugae's memory.
Input
The first line consists of an integer n (1 β€ n β€ 10^5), the number of events in Amugae's memory.
The second line consists of a string of length n describing the events in chronological order. Each character represents:
* 'L': A customer arrives from the left entrance.
* 'R': A customer arrives from the right entrance.
* '0', '1', ..., '9': The customer in room x (0, 1, ..., 9 respectively) leaves.
It is guaranteed that there is at least one empty room when a customer arrives, and there is a customer in the room x when x (0, 1, ..., 9) is given. Also, all the rooms are initially empty.
Output
In the only line, output the hotel room's assignment status, from room 0 to room 9. Represent an empty room as '0', and an occupied room as '1', without spaces.
Examples
Input
8
LLRL1RL1
Output
1010000011
Input
9
L0L0LLRR9
Output
1100000010
Note
In the first example, hotel room's assignment status after each action is as follows.
* First of all, all rooms are empty. Assignment status is 0000000000.
* L: a customer arrives to the hotel through the left entrance. Assignment status is 1000000000.
* L: one more customer from the left entrance. Assignment status is 1100000000.
* R: one more customer from the right entrance. Assignment status is 1100000001.
* L: one more customer from the left entrance. Assignment status is 1110000001.
* 1: the customer in room 1 leaves. Assignment status is 1010000001.
* R: one more customer from the right entrance. Assignment status is 1010000011.
* L: one more customer from the left entrance. Assignment status is 1110000011.
* 1: the customer in room 1 leaves. Assignment status is 1010000011.
So after all, hotel room's final assignment status is 1010000011.
In the second example, hotel room's assignment status after each action is as follows.
* L: a customer arrives to the hotel through the left entrance. Assignment status is 1000000000.
* 0: the customer in room 0 leaves. Assignment status is 0000000000.
* L: a customer arrives to the hotel through the left entrance. Assignment status is 1000000000 again.
* 0: the customer in room 0 leaves. Assignment status is 0000000000.
* L: a customer arrives to the hotel through the left entrance. Assignment status is 1000000000.
* L: one more customer from the left entrance. Assignment status is 1100000000.
* R: one more customer from the right entrance. Assignment status is 1100000001.
* R: one more customer from the right entrance. Assignment status is 1100000011.
* 9: the customer in room 9 leaves. Assignment status is 1100000010.
So after all, hotel room's final assignment status is 1100000010. | def rooms(l,c):
if c=='L':
l[l.index(0)]=1
elif c=='R':
l[9-l[::-1].index(0)]=1
else:
l[int(c)]=0
n=int(input())
l=[0,0,0,0,0,0,0,0,0,0]
for i in list(input()):
rooms(l,i)
print("".join(str(l).split(', '))[1:-1]) | {
"input": [
"9\nL0L0LLRR9\n",
"8\nLLRL1RL1\n"
],
"output": [
"1100000010\n",
"1010000011\n"
]
} |
2,021 | 12 | There are n football teams in the world.
The Main Football Organization (MFO) wants to host at most m games. MFO wants the i-th game to be played between the teams a_i and b_i in one of the k stadiums.
Let s_{ij} be the numbers of games the i-th team played in the j-th stadium. MFO does not want a team to have much more games in one stadium than in the others. Therefore, for each team i, the absolute difference between the maximum and minimum among s_{i1}, s_{i2}, β¦, s_{ik} should not exceed 2.
Each team has w_i β the amount of money MFO will earn for each game of the i-th team. If the i-th team plays l games, MFO will earn w_i β
l.
MFO needs to find what games in what stadiums they need to host in order to earn as much money as possible, not violating the rule they set.
However, this problem is too complicated for MFO. Therefore, they are asking you to help them.
Input
The first line contains three integers n, m, k (3 β€ n β€ 100, 0 β€ m β€ 1 000, 1 β€ k β€ 1 000) β the number of teams, the number of games, and the number of stadiums.
The second line contains n integers w_1, w_2, β¦, w_n (1 β€ w_i β€ 1 000) β the amount of money MFO will earn for each game of the i-th game.
Each of the following m lines contains two integers a_i and b_i (1 β€ a_i, b_i β€ n, a_i β b_i) β the teams that can play the i-th game. It is guaranteed that each pair of teams can play at most one game.
Output
For each game in the same order, print t_i (1 β€ t_i β€ k) β the number of the stadium, in which a_i and b_i will play the game. If the i-th game should not be played, t_i should be equal to 0.
If there are multiple answers, print any.
Example
Input
7 11 3
4 7 8 10 10 9 3
6 2
6 1
7 6
4 3
4 6
3 1
5 3
7 5
7 3
4 2
1 4
Output
3
2
1
1
3
1
2
1
2
3
2
Note
One of possible solutions to the example is shown below:
<image> | import random
import math
def set_color(game, color):
color_count[game[0]][game[2]] -= 1
color_count[game[1]][game[2]] -= 1
game[2] = color
color_count[game[0]][game[2]] += 1
color_count[game[1]][game[2]] += 1
def fix(node):
minimum = math.inf
maximum = 0
for i in range(k):
minimum = min(minimum, color_count[node][i])
maximum = max(maximum, color_count[node][i])
if maximum - minimum <= 2:
return False
rand = 0
for game in games:
if (game[0] == node or game[1] == node) and color_count[node][game[2]] == maximum:
rand = r(1,k)
set_color(game, rand % k)
return True
return False
n, m, k = map(int,input().split())
games = [[0 for _ in range(4)] for _ in range(m)]
color_count = [[0 for _ in range(k)] for _ in range(n)]
answers = [0 for _ in range(m)]
_ = list(map(int,input().split()))
color = 0
r = lambda x,y : random.randint(x,y)
for i in range(m):
a, b = map(int,input().split())
color = r(1,k) % k
games[i] = [a-1,b-1,color,i]
color_count[games[i][0]][color] += 1
color_count[games[i][1]][color] += 1
bad = True
while bad:
random.shuffle(games)
bad = False
for i in range(n):
while(fix(i)):
bad = True
for game in games:
answers[game[3]] = game[2] + 1
for i in range(m):
print(answers[i])
| {
"input": [
"7 11 3\n4 7 8 10 10 9 3\n6 2\n6 1\n7 6\n4 3\n4 6\n3 1\n5 3\n7 5\n7 3\n4 2\n1 4\n"
],
"output": [
"1\n2\n1\n1\n2\n1\n2\n2\n3\n3\n1\n"
]
} |
2,022 | 7 | 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}... 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 ... r]=s_l, s_{l+1}, ..., s_r and change the order of elements in it into s_r, s_{r-1}, ..., s_{l}.
For example, if you will decide to reverse substring s[2 ... 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 β€ t β€ 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 β€ k β€ n/2, 2 β€ n β€ 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 n/2 characters '(' and exactly 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 β€ m β€ 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 β€ l β€ r β€ n), representing single reverse operation of s[l ... r]=s_{l}s_{l+1}... 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). | t = int(input())
for _ in range(t):
n,k = list(map(int, input().strip().split()))
s = list(input().strip())
target = []
t_len = n
for i in range(k-1):
target.append('(')
target.append(')')
t_len -= 2
for i in range(t_len // 2):
target.append('(')
for i in range(t_len // 2):
target.append(')')
def rev(i,j):
while i<j:
s[i], s[j] = s[j], s[i]
i += 1
j -= 1
ans = []
for i in range(n):
if s[i] != target[i]:
j = i+1
while j<n and s[j] != target[i]:
j += 1
rev(i,j)
ans.append([i+1,j+1])
print(len(ans))
for x,y in ans:
print(x,y, sep = ' ') | {
"input": [
"4\n8 2\n()(())()\n10 3\n))()()()((\n2 1\n()\n2 1\n)(\n"
],
"output": [
"1\n5 7\n5\n1 3\n3 5\n5 7\n6 9\n7 10\n0\n1\n1 2\n"
]
} |
2,023 | 8 | Santa has n candies and he wants to gift them to k kids. He wants to divide as many candies as possible between all k kids. Santa can't divide one candy into parts but he is allowed to not use some candies at all.
Suppose the kid who recieves the minimum number of candies has a candies and the kid who recieves the maximum number of candies has b candies. Then Santa will be satisfied, if the both conditions are met at the same time:
* b - a β€ 1 (it means b = a or b = a + 1);
* the number of kids who has a+1 candies (note that a+1 not necessarily equals b) does not exceed βk/2β (less than or equal to βk/2β).
βk/2β is k divided by 2 and rounded down to the nearest integer. For example, if k=5 then βk/2β=β5/2β=2.
Your task is to find the maximum number of candies Santa can give to kids so that he will be satisfied.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 β€ t β€ 5 β
10^4) β the number of test cases.
The next t lines describe test cases. The i-th test case contains two integers n and k (1 β€ n, k β€ 10^9) β the number of candies and the number of kids.
Output
For each test case print the answer on it β the maximum number of candies Santa can give to kids so that he will be satisfied.
Example
Input
5
5 2
19 4
12 7
6 2
100000 50010
Output
5
18
10
6
75015
Note
In the first test case, Santa can give 3 and 2 candies to kids. There a=2, b=3,a+1=3.
In the second test case, Santa can give 5, 5, 4 and 4 candies. There a=4,b=5,a+1=5. The answer cannot be greater because then the number of kids with 5 candies will be 3.
In the third test case, Santa can distribute candies in the following way: [1, 2, 2, 1, 1, 2, 1]. There a=1,b=2,a+1=2. He cannot distribute two remaining candies in a way to be satisfied.
In the fourth test case, Santa can distribute candies in the following way: [3, 3]. There a=3, b=3, a+1=4. Santa distributed all 6 candies. | def f(n,k):
if n%k>k//2:
return n-(n%k)+k//2
else:
return n
t=int(input())
for i in range(t):
n,k=map(int,input().split())
print(f(n,k)) | {
"input": [
"5\n5 2\n19 4\n12 7\n6 2\n100000 50010\n"
],
"output": [
"5\n18\n10\n6\n75015\n"
]
} |
2,024 | 12 | This is an easy version of the problem. In this version, all numbers in the given array are distinct and the constraints on n are less than in the hard version of the problem.
You are given an array a of n integers (there are no equals elements in the array). You can perform the following operations on array elements:
1. choose any index i (1 β€ i β€ n) and move the element a[i] to the begin of the array;
2. choose any index i (1 β€ i β€ n) and move the element a[i] to the end of the array.
For example, if n = 5, a = [4, 7, 2, 3, 9], then the following sequence of operations can be performed:
* after performing the operation of the first type to the second element, the array a will become [7, 4, 2, 3, 9];
* after performing the operation of the second type to the second element, the array a will become [7, 2, 3, 9, 4].
You can perform operations of any type any number of times in any order.
Find the minimum total number of operations of the first and second type that will make the a array sorted in non-decreasing order. In other words, what is the minimum number of operations that must be performed so the array satisfies the inequalities a[1] β€ a[2] β€ β¦ β€ a[n].
Input
The first line contains a single integer t (1 β€ t β€ 100) β the number of test cases in the test. Then t test cases follow.
Each test case starts with a line containing an integer n (1 β€ n β€ 3000) β length of the array a.
Then follow n integers a_1, a_2, β¦, a_n (0 β€ a_i β€ 10^9) β an array that needs to be sorted by the given operations. All numbers in the given array are distinct.
The sum of n for all test cases in one test does not exceed 3000.
Output
For each test case output one integer β the minimum total number of operations of the first and second type, which will make the array sorted in non-decreasing order.
Example
Input
4
5
4 7 2 3 9
5
3 5 8 1 7
5
1 4 5 7 12
4
0 2 1 3
Output
2
2
0
2
Note
In the first test case, you first need to move 3, and then 2 to the beginning of the array. Therefore, the desired sequence of operations: [4, 7, 2, 3, 9] β [3, 4, 7, 2, 9] β [2, 3, 4, 7, 9].
In the second test case, you need to move the 1 to the beginning of the array, and the 8 β to the end. Therefore, the desired sequence of operations: [3, 5, 8, 1, 7] β [1, 3, 5, 8, 7] β [1, 3, 5, 7, 8].
In the third test case, the array is already sorted. | from sys import stdin,stdout
def findops(l,ans,count):
for i in range(1,len(l)):
if l[i]>l[i-1]:count+=1
else:ans,count = max(ans,count),1
return len(l)-max(ans,count)
for _ in range(int(stdin.readline())):
input()
l=list(map(int,input().split()))
print(findops(sorted(range(len(l)),key=lambda x:l[x]),0,1)) | {
"input": [
"4\n5\n4 7 2 3 9\n5\n3 5 8 1 7\n5\n1 4 5 7 12\n4\n0 2 1 3\n"
],
"output": [
"2\n2\n0\n2\n"
]
} |
2,025 | 7 | Let LCM(x, y) be the minimum positive integer that is divisible by both x and y. For example, LCM(13, 37) = 481, LCM(9, 6) = 18.
You are given two integers l and r. Find two integers x and y such that l β€ x < y β€ r and l β€ LCM(x, y) β€ r.
Input
The first line contains one integer t (1 β€ t β€ 10000) β the number of test cases.
Each test case is represented by one line containing two integers l and r (1 β€ l < r β€ 10^9).
Output
For each test case, print two integers:
* if it is impossible to find integers x and y meeting the constraints in the statement, print two integers equal to -1;
* otherwise, print the values of x and y (if there are multiple valid answers, you may print any of them).
Example
Input
4
1 1337
13 69
2 4
88 89
Output
6 7
14 21
2 4
-1 -1 | def func():
l,r = map(int, input().split())
if (2*l <= r):
print(l,l*2)
else:
print("-1 -1")
for _ in range(int(input())):
func() | {
"input": [
"4\n1 1337\n13 69\n2 4\n88 89\n"
],
"output": [
"1 2\n13 26\n2 4\n-1 -1\n"
]
} |
2,026 | 10 | You are given a positive integer n. In one move, you can increase n by one (i.e. make n := n + 1). Your task is to find the minimum number of moves you need to perform in order to make the sum of digits of n be less than or equal to s.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 β€ t β€ 2 β
10^4) β the number of test cases. Then t test cases follow.
The only line of the test case contains two integers n and s (1 β€ n β€ 10^{18}; 1 β€ s β€ 162).
Output
For each test case, print the answer: the minimum number of moves you need to perform in order to make the sum of digits of n be less than or equal to s.
Example
Input
5
2 1
1 1
500 4
217871987498122 10
100000000000000001 1
Output
8
0
500
2128012501878
899999999999999999 | def ab(a,b):
return (b-a%b)%b
for i in range(int(input())):
a,b=map(int,input().split())
print(ab(a,b))
| {
"input": [
"5\n2 1\n1 1\n500 4\n217871987498122 10\n100000000000000001 1\n"
],
"output": [
"0\n0\n0\n8\n0\n"
]
} |
2,027 | 8 | 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 β€ t β€ 1000) β the number of test cases.
The first line of each test case contains two integers n and k (1 β€ k < n β€ 2 β
10^5) β the number of barrels and the number of pourings you can make.
The second line contains n integers a_1, a_2, ..., a_n (0 β€ a_i β€ 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 β
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 solve(n,k,l):
l.sort()
return sum(l[-k-1:])
for i in range(int(input())):
print(solve(*map(int,input().split()),list(map(int,input().split())))) | {
"input": [
"2\n4 1\n5 5 5 5\n3 2\n0 0 0\n"
],
"output": [
"10\n0\n"
]
} |
2,028 | 10 | Gildong is developing a game consisting of n stages numbered from 1 to n. The player starts the game from the 1-st stage and should beat the stages in increasing order of the stage number. The player wins the game after beating the n-th stage.
There is at most one checkpoint on each stage, and there is always a checkpoint on the 1-st stage. At the beginning of the game, only the checkpoint on the 1-st stage is activated, and all other checkpoints are deactivated. When the player gets to the i-th stage that has a checkpoint, that checkpoint is activated.
For each try of a stage, the player can either beat the stage or fail the stage. If they beat the i-th stage, the player is moved to the i+1-st stage. If they fail the i-th stage, the player is moved to the most recent checkpoint they activated, and they have to beat the stages after that checkpoint again.
For example, assume that n = 4 and the checkpoints are on the 1-st and 3-rd stages. The player starts at the 1-st stage. If they fail on the 1-st stage, they need to retry the 1-st stage because the checkpoint on the 1-st stage is the most recent checkpoint they activated. If the player beats the 1-st stage, they're moved to the 2-nd stage. If they fail it, they're sent back to the 1-st stage again. If they beat both the 1-st stage and the 2-nd stage, they get to the 3-rd stage and the checkpoint on the 3-rd stage is activated. Now whenever they fail on the 3-rd stage, or the 4-th stage after beating the 3-rd stage, they're sent back to the 3-rd stage. If they beat both the 3-rd stage and the 4-th stage, they win the game.
Gildong is going to build the stages to have equal difficulty. He wants you to find any series of stages and checkpoints using at most 2000 stages, where the [expected number](https://en.wikipedia.org/wiki/Expected_value) of tries over all stages is exactly k, for a player whose probability of beating each stage is exactly \cfrac{1}{2}.
Input
Each test contains one or more test cases. The first line contains the number of test cases t (1 β€ t β€ 50).
Each test case contains exactly one line. The line consists of a single integer k (1 β€ k β€ 10^{18}) β the expected number of tries over all stages Gildong wants to set for a player whose probability of beating each stage is exactly \cfrac{1}{2}.
Output
For each test case, print -1 if it's impossible to construct such a series of stages and checkpoints using at most 2000 stages.
Otherwise, print two lines. The first line should contain a single integer n (1 β€ n β€ 2000) β the number of stages. The second line should contain n integers, where the i-th integer represents whether the i-th stage has a checkpoint. The i-th integer should be 0 if the i-th stage doesn't have a checkpoint, and 1 if it has a checkpoint. Note that the first integer must be 1 according to the description.
Example
Input
4
1
2
8
12
Output
-1
1
1
4
1 1 1 1
5
1 1 0 1 1
Note
In the first and the second case, we can see that the 'easiest' series of stages is to have 1 stage with a checkpoint. This already requires 2 tries in expectation, so it is impossible to make it to require only 1 try.
In the third case, it takes 2 tries in expectation to beat each stage, and the player can always retry that stage without falling back to one of the previous stages if they fail it. Therefore the total expected number of tries is 8. Note that there exists an answer with fewer stages, but you are not required to minimize the number of stages used. | l = [2 ** i - 2 for i in range(2, 61)]
def main(n):
s = 2;r = [1];i = len(l) - 1
while i >= 0:
if s + l[i] > n: i -= 1
else:s += l[i];r += [1] + [0] * i
if s != n: return '-1'
else: return f'''{len(r)}
{' '.join(map(str, r))}'''
for _ in range(int(input())):print(main(int(input()))) | {
"input": [
"4\n1\n2\n8\n12\n"
],
"output": [
"\n-1\n1\n1\n4\n1 1 1 1\n5\n1 1 0 1 1\n"
]
} |
2,029 | 8 | Nezzar has a binary string s of length n that he wants to share with his best friend, Nanako. Nanako will spend q days inspecting the binary string. At the same time, Nezzar wants to change the string s into string f during these q days, because it looks better.
It is known that Nanako loves consistency so much. On the i-th day, Nanako will inspect a segment of string s from position l_i to position r_i inclusive. If the segment contains both characters '0' and '1', Nanako becomes unhappy and throws away the string.
After this inspection, at the i-th night, Nezzar can secretly change strictly less than half of the characters in the segment from l_i to r_i inclusive, otherwise the change will be too obvious.
Now Nezzar wonders, if it is possible to avoid Nanako being unhappy and at the same time have the string become equal to the string f at the end of these q days and nights.
Input
The first line contains a single integer t (1 β€ t β€ 2 β
10^5) β the number of test cases.
The first line of each test case contains two integers n,q (1 β€ n β€ 2 β
10^5, 0 β€ q β€ 2 β
10^5).
The second line of each test case contains a binary string s of length n.
The third line of each test case contains a binary string f of length n.
Then q lines follow, i-th of them contains two integers l_i,r_i (1 β€ l_i β€ r_i β€ n) β bounds of the segment, that Nanako will inspect on the i-th day.
It is guaranteed that the sum of n for all test cases doesn't exceed 2 β
10^5, and the sum of q for all test cases doesn't exceed 2 β
10^5.
Output
For each test case, print "YES" on the single line if it is possible to avoid Nanako being unhappy and have the string f at the end of q days and nights. Otherwise, print "NO".
You can print each letter in any case (upper or lower).
Example
Input
4
5 2
00000
00111
1 5
1 3
2 1
00
01
1 2
10 6
1111111111
0110001110
1 10
5 9
7 10
1 7
3 5
6 10
5 2
10000
11000
2 5
1 3
Output
YES
NO
YES
NO
Note
In the first test case, \underline{00000} β \underline{000}11 β 00111 is one of the possible sequences of string changes.
In the second test case, it can be shown that it is impossible to have the string f at the end. | import sys
input = sys.stdin.readline
def indexes(L,R):
INDLIST=[]
R-=1
L>>=1
R>>=1
while L!=R:
if L>R:
INDLIST.append(L)
L>>=1
else:
INDLIST.append(R)
R>>=1
while L!=0:
INDLIST.append(L)
L>>=1
return INDLIST
def updates(l,r,x):
L=l+seg_el
R=r+seg_el
L//=(L & (-L))
R//=(R & (-R))
UPIND=indexes(L,R)
for ind in UPIND[::-1]:
if LAZY[ind]!=None:
update_lazy = LAZY[ind] *(1<<(seg_height - 1 - (ind.bit_length())))
LAZY[ind<<1]=LAZY[1+(ind<<1)]=LAZY[ind]
SEG[ind<<1]=SEG[1+(ind<<1)]=update_lazy
LAZY[ind]=None
while L!=R:
if L > R:
SEG[L]=x * (1<<(seg_height - (L.bit_length())))
LAZY[L]=x
L+=1
L//=(L & (-L))
else:
R-=1
SEG[R]=x * (1<<(seg_height - (R.bit_length())))
LAZY[R]=x
R//=(R & (-R))
for ind in UPIND:
SEG[ind]=SEG[ind<<1]+SEG[1+(ind<<1)]
def getvalues(l,r):
L=l+seg_el
R=r+seg_el
L//=(L & (-L))
R//=(R & (-R))
UPIND=indexes(L,R)
for ind in UPIND[::-1]:
if LAZY[ind]!=None:
update_lazy = LAZY[ind] *(1<<(seg_height - 1 - (ind.bit_length())))
LAZY[ind<<1]=LAZY[1+(ind<<1)]=LAZY[ind]
SEG[ind<<1]=SEG[1+(ind<<1)]=update_lazy
LAZY[ind]=None
ANS=0
while L!=R:
if L > R:
ANS+=SEG[L]
L+=1
L//=(L & (-L))
else:
R-=1
ANS+=SEG[R]
R//=(R & (-R))
return ANS
t=int(input())
for tests in range(t):
n,q=map(int,input().split())
S=input().strip()
F=input().strip()
Q=[tuple(map(int,input().split())) for i in range(q)]
seg_el=1<<(n.bit_length())
seg_height=1+n.bit_length()
SEG=[0]*(2*seg_el)
LAZY=[None]*(2*seg_el)
for i in range(n):
SEG[i+seg_el]=int(F[i])
for i in range(seg_el-1,0,-1):
SEG[i]=SEG[i*2]+SEG[i*2+1]
for l,r in Q[::-1]:
SUM=r-l+1
xx=getvalues(l-1,r)
if xx*2==SUM:
print("NO")
break
else:
if xx*2>SUM:
updates(l-1,r,1)
else:
updates(l-1,r,0)
else:
for i in range(n):
if getvalues(i,i+1)==int(S[i]):
True
else:
print("NO")
break
else:
print("YES")
| {
"input": [
"4\n5 2\n00000\n00111\n1 5\n1 3\n2 1\n00\n01\n1 2\n10 6\n1111111111\n0110001110\n1 10\n5 9\n7 10\n1 7\n3 5\n6 10\n5 2\n10000\n11000\n2 5\n1 3\n"
],
"output": [
"\nYES\nNO\nYES\nNO\n"
]
} |
2,030 | 10 | You are given a tree with n nodes, numerated from 0 to n-1. For each k between 0 and n, inclusive, you have to count the number of unordered pairs (u,v), u β v, such that the MEX of all the node labels in the shortest path from u to v (including end points) is k.
The MEX of a sequence of integers is the smallest non-negative integer that does not belong to the sequence.
Input
The first line contains a single integer t (1 β€ t β€ 10^4) β the number of test cases.
The first line of each test case contains a single integer n (2 β€ n β€ 2 β
10^{5}).
The next n-1 lines of each test case describe the tree that has to be constructed. These lines contain two integers u and v (0 β€ u,v β€ n-1) denoting an edge between u and v (u β v).
It is guaranteed that the given edges form a tree.
It is also guaranteed that the sum of n for all test cases does not exceed 2 β
10^{5}.
Output
For each test case, print n+1 integers: the number of paths in the tree, such that the MEX of all the node labels in that path is k for each k from 0 to n.
Example
Input
2
4
0 1
0 2
2 3
2
1 0
Output
1 2 1 1 1
0 0 1
Note
1. In example case 1, <image>
* For k = 0, there is 1 path that is from 2 to 3 as MEX([2, 3]) = 0.
* For k = 1, there are 2 paths that is from 0 to 2 as MEX([0, 2]) = 1 and 0 to 3 as MEX([0, 2, 3]) = 1.
* For k = 2, there is 1 path that is from 0 to 1 as MEX([0, 1]) = 2.
* For k = 3, there is 1 path that is from 1 to 2 as MEX([1, 0, 2]) = 3
* For k = 4, there is 1 path that is from 1 to 3 as MEX([1, 0, 2, 3]) = 4.
2. In example case 2, <image>
* For k = 0, there are no such paths.
* For k = 1, there are no such paths.
* For k = 2, there is 1 path that is from 0 to 1 as MEX([0, 1]) = 2. | import sys
from collections import deque
input = sys.stdin.readline
def solve():
n = int(input())
G = [[] for _ in range(n)]
for _ in range(n-1):
a,b = map(int,input().split())
G[a].append(b)
G[b].append(a)
size = [0]*n
par = [-1]*n
stk = [0]
visited = [False]*n
while stk:
x = stk[-1]
if not visited[x]:
visited[x] = True
for y in G[x]:
if not visited[y]:
par[y] = x
stk.append(y)
else:
stk.pop()
for y in G[x]:
size[x] += size[y]
size[x] += 1
visited = [False]*n
ans = [0]*(n+1)
for y in G[0]:
ans[0] += size[y] * (size[y]-1) // 2
P = n*(n-1)//2
P -= ans[0]
visited[0] = True
l,r = 0,0
for i in range(1,n):
if visited[i]:
ans[i] = P - size[r] * size[l]
continue
u = i
acc = 0
while not visited[u]:
visited[u] = True
if par[u] == 0:
size[0] -= size[u]
u = par[u]
if u == l:
ans[i] = P - size[r] * size[i]
l = i
P = size[r] * size[l]
elif u == r:
ans[i] = P - size[l] * size[i]
r = i
P = size[r] * size[l]
else:
ans[i] = P
P = 0
break
ans[-1] = P
print(*ans)
for nt in range(int(input())):
solve()
| {
"input": [
"2\n4\n0 1\n0 2\n2 3\n2\n1 0\n"
],
"output": [
"\n1 2 1 1 1 \n0 0 1 \n"
]
} |
2,031 | 9 | One popular website developed an unusual username editing procedure. One can change the username only by deleting some characters from it: to change the current name s, a user can pick number p and character c and delete the p-th occurrence of character c from the name. After the user changed his name, he can't undo the change.
For example, one can change name "arca" by removing the second occurrence of character "a" to get "arc".
Polycarpus learned that some user initially registered under nickname t, where t is a concatenation of k copies of string s. Also, Polycarpus knows the sequence of this user's name changes. Help Polycarpus figure out the user's final name.
Input
The first line contains an integer k (1 β€ k β€ 2000). The second line contains a non-empty string s, consisting of lowercase Latin letters, at most 100 characters long. The third line contains an integer n (0 β€ n β€ 20000) β the number of username changes. Each of the next n lines contains the actual changes, one per line. The changes are written as "pi ci" (without the quotes), where pi (1 β€ pi β€ 200000) is the number of occurrences of letter ci, ci is a lowercase Latin letter. It is guaranteed that the operations are correct, that is, the letter to be deleted always exists, and after all operations not all letters are deleted from the name. The letters' occurrences are numbered starting from 1.
Output
Print a single string β the user's final name after all changes are applied to it.
Examples
Input
2
bac
3
2 a
1 b
2 c
Output
acb
Input
1
abacaba
4
1 a
1 a
1 c
2 b
Output
baa
Note
Let's consider the first sample. Initially we have name "bacbac"; the first operation transforms it into "bacbc", the second one β to "acbc", and finally, the third one transforms it into "acb". | #copied... idea
def main():
mode="filee"
if mode=="file":f=open("test.txt","r")
get = lambda :[int(x) for x in (f.readline() if mode=="file" else input()).split()]
gets = lambda :[str(x) for x in (f.readline() if mode=="file" else input()).split()]
[k]=get()
[g]=gets()
h = g*k
h = list(h)
p = []
for i in range(128):
p.append([0])
for i in range(len(h)):
p[ord(h[i])].append(i)
[n]=get()
for i in range(n):
[x,y]=gets()
x = int(x)
h[p[ord(y)][x]]=''
p[ord(y)].pop(x)
print("".join(h))
if mode=="file":f.close()
if __name__=="__main__":
main()
| {
"input": [
"2\nbac\n3\n2 a\n1 b\n2 c\n",
"1\nabacaba\n4\n1 a\n1 a\n1 c\n2 b\n"
],
"output": [
"acb\n",
"baa\n"
]
} |
2,032 | 7 | Consider some square matrix A with side n consisting of zeros and ones. There are n rows numbered from 1 to n from top to bottom and n columns numbered from 1 to n from left to right in this matrix. We'll denote the element of the matrix which is located at the intersection of the i-row and the j-th column as Ai, j.
Let's call matrix A clear if no two cells containing ones have a common side.
Let's call matrix A symmetrical if it matches the matrices formed from it by a horizontal and/or a vertical reflection. Formally, for each pair (i, j) (1 β€ i, j β€ n) both of the following conditions must be met: Ai, j = An - i + 1, j and Ai, j = Ai, n - j + 1.
Let's define the sharpness of matrix A as the number of ones in it.
Given integer x, your task is to find the smallest positive integer n such that there exists a clear symmetrical matrix A with side n and sharpness x.
Input
The only line contains a single integer x (1 β€ x β€ 100) β the required sharpness of the matrix.
Output
Print a single number β the sought value of n.
Examples
Input
4
Output
3
Input
9
Output
5
Note
The figure below shows the matrices that correspond to the samples:
<image> | def symmetry(x):
if x == 3:
return 5
k = 1
while k * k // 2 + 1 < x:
k += 2
return k
print(symmetry(int(input()))) | {
"input": [
"9\n",
"4\n"
],
"output": [
"5\n",
"3\n"
]
} |
2,033 | 11 | Consider the following equation:
<image> where sign [a] represents the integer part of number a.
Let's find all integer z (z > 0), for which this equation is unsolvable in positive integers. The phrase "unsolvable in positive integers" means that there are no such positive integers x and y (x, y > 0), for which the given above equation holds.
Let's write out all such z in the increasing order: z1, z2, z3, and so on (zi < zi + 1). Your task is: given the number n, find the number zn.
Input
The first line contains a single integer n (1 β€ n β€ 40).
Output
Print a single integer β the number zn modulo 1000000007 (109 + 7). It is guaranteed that the answer exists.
Examples
Input
1
Output
1
Input
2
Output
3
Input
3
Output
15 | from bisect import bisect_left as bl
from bisect import bisect_right as br
import heapq
import math
from collections import *
from functools import reduce,cmp_to_key
import sys
input = sys.stdin.readline
# M = mod = 998244353
def factors(n):return sorted(set(reduce(list.__add__, ([i, n//i] for i in range(1, int(n**0.5) + 1) if n % i == 0))))
# def inv_mod(n):return pow(n, mod - 2, mod)
def li():return [int(i) for i in input().rstrip('\n').split()]
def st():return input().rstrip('\n')
def val():return int(input().rstrip('\n'))
def li2():return [i for i in input().rstrip('\n').split(' ')]
def li3():return [int(i) for i in input().rstrip('\n')]
l = [2,3,5,7,13,17,19,31,61,89,107,127,521,607,1279,2203,2281,3217,4253,4423,9689,9941,11213,19937,21701,23209,44497,86243,110503,132049,216091,756839,859433,1257787,1398269,2976221,3021377,6972593,13466917,20996011,24036583]
n = val()
curr = l[n-1]-1
print((pow(2,curr)-1)%(10**9 + 7)) | {
"input": [
"2\n",
"3\n",
"1\n"
],
"output": [
" 3\n",
" 15\n",
" 1\n"
]
} |
2,034 | 9 | You are given the following points with integer coordinates on the plane: M0, A0, A1, ..., An - 1, where n is odd number. Now we define the following infinite sequence of points Mi: Mi is symmetric to Mi - 1 according <image> (for every natural number i). Here point B is symmetric to A according M, if M is the center of the line segment AB. Given index j find the point Mj.
Input
On the first line you will be given an integer n (1 β€ n β€ 105), which will be odd, and j (1 β€ j β€ 1018), where j is the index of the desired point. The next line contains two space separated integers, the coordinates of M0. After that n lines follow, where the i-th line contain the space separated integer coordinates of the point Ai - 1. The absolute values of all input coordinates will not be greater then 1000.
Output
On a single line output the coordinates of Mj, space separated.
Examples
Input
3 4
0 0
1 1
2 3
-5 3
Output
14 0
Input
3 1
5 5
1000 1000
-1000 1000
3 100
Output
1995 1995 | import sys
def read():
tokens = sys.stdin.readline().strip().split()
return int(tokens[0]), int(tokens[1])
n,m=read()
p,q=read()
x=[]
y=[]
r=1
for i in range(0,n*2):
if (i<n):
tx,ty=read()
x.append(tx)
y.append(ty)
else:
x.append(x[i-n])
y.append(y[i-n])
m%=n*2
for i in range(0,m):
p=2*x[i]-p
q=2*y[i]-q
print (p,q)
'''
(x,y) (ax,ay) (ax*2-x,ay*2-y)
(x,y,1)(-1 0 0
0 -1 0
ax*2 ay*2 1)
''' | {
"input": [
"3 4\n0 0\n1 1\n2 3\n-5 3\n",
"3 1\n5 5\n1000 1000\n-1000 1000\n3 100\n"
],
"output": [
"14 0\n",
"1995 1995\n"
]
} |
2,035 | 7 | There is a straight snowy road, divided into n blocks. The blocks are numbered from 1 to n from left to right. If one moves from the i-th block to the (i + 1)-th block, he will leave a right footprint on the i-th block. Similarly, if one moves from the i-th block to the (i - 1)-th block, he will leave a left footprint on the i-th block. If there already is a footprint on the i-th block, the new footprint will cover the old one.
<image>
At the beginning, there were no footprints. Then polar bear Alice starts from the s-th block, makes a sequence of moves and ends in the t-th block. It is known that Alice never moves outside of the road.
You are given the description of Alice's footprints. Your task is to find a pair of possible values of s, t by looking at the footprints.
Input
The first line of the input contains integer n (3 β€ n β€ 1000).
The second line contains the description of the road β the string that consists of n characters. Each character will be either "." (a block without footprint), or "L" (a block with a left footprint), "R" (a block with a right footprint).
It's guaranteed that the given string contains at least one character not equal to ".". Also, the first and the last character will always be ".". It's guaranteed that a solution exists.
Output
Print two space-separated integers β the values of s and t. If there are several possible solutions you can print any of them.
Examples
Input
9
..RRLL...
Output
3 4
Input
11
.RRRLLLLL..
Output
7 5
Note
The first test sample is the one in the picture. | def main():
n, s = int(input()), input()
r, l = s.find('R') + 1, s.rfind("L") + 1
if not r:
print(l, l - s.count('L'))
elif not l :
print(r, r + s.count('R'))
else:
print(r, s.find('RL') + 1)
if __name__ == '__main__':
main()
| {
"input": [
"11\n.RRRLLLLL..\n",
"9\n..RRLL...\n"
],
"output": [
"2 4\n",
"3 4\n"
]
} |
2,036 | 7 | Valera is a lazy student. He has m clean bowls and k clean plates.
Valera has made an eating plan for the next n days. As Valera is lazy, he will eat exactly one dish per day. At that, in order to eat a dish, he needs exactly one clean plate or bowl. We know that Valera can cook only two types of dishes. He can eat dishes of the first type from bowls and dishes of the second type from either bowls or plates.
When Valera finishes eating, he leaves a dirty plate/bowl behind. His life philosophy doesn't let him eat from dirty kitchenware. So sometimes he needs to wash his plate/bowl before eating. Find the minimum number of times Valera will need to wash a plate/bowl, if he acts optimally.
Input
The first line of the input contains three integers n, m, k (1 β€ n, m, k β€ 1000) β the number of the planned days, the number of clean bowls and the number of clean plates.
The second line contains n integers a1, a2, ..., an (1 β€ ai β€ 2). If ai equals one, then on day i Valera will eat a first type dish. If ai equals two, then on day i Valera will eat a second type dish.
Output
Print a single integer β the minimum number of times Valera will need to wash a plate/bowl.
Examples
Input
3 1 1
1 2 1
Output
1
Input
4 3 1
1 1 1 1
Output
1
Input
3 1 2
2 2 2
Output
0
Input
8 2 2
1 2 1 2 1 2 1 2
Output
4
Note
In the first sample Valera will wash a bowl only on the third day, so the answer is one.
In the second sample, Valera will have the first type of the dish during all four days, and since there are only three bowls, he will wash a bowl exactly once.
In the third sample, Valera will have the second type of dish for all three days, and as they can be eaten from either a plate or a bowl, he will never need to wash a plate/bowl. | from sys import stdin
def main():
n, m, k = map(int, stdin.readline().strip().split())
l = [0, 0, 0]
for x in map(int, stdin.readline().strip().split()):
l[x] += 1
return max(sum(l) - m - k, l[1] - m, 0)
print(main())
| {
"input": [
"4 3 1\n1 1 1 1\n",
"3 1 2\n2 2 2\n",
"3 1 1\n1 2 1\n",
"8 2 2\n1 2 1 2 1 2 1 2\n"
],
"output": [
"1",
"0",
"1",
"4"
]
} |
2,037 | 7 | Not so long ago company R2 bought company R1 and consequently, all its developments in the field of multicore processors. Now the R2 laboratory is testing one of the R1 processors.
The testing goes in n steps, at each step the processor gets some instructions, and then its temperature is measured. The head engineer in R2 is keeping a report record on the work of the processor: he writes down the minimum and the maximum measured temperature in his notebook. His assistant had to write down all temperatures into his notebook, but (for unknown reasons) he recorded only m.
The next day, the engineer's assistant filed in a report with all the m temperatures. However, the chief engineer doubts that the assistant wrote down everything correctly (naturally, the chief engineer doesn't doubt his notes). So he asked you to help him. Given numbers n, m, min, max and the list of m temperatures determine whether you can upgrade the set of m temperatures to the set of n temperatures (that is add n - m temperatures), so that the minimum temperature was min and the maximum one was max.
Input
The first line contains four integers n, m, min, max (1 β€ m < n β€ 100; 1 β€ min < max β€ 100). The second line contains m space-separated integers ti (1 β€ ti β€ 100) β the temperatures reported by the assistant.
Note, that the reported temperatures, and the temperatures you want to add can contain equal temperatures.
Output
If the data is consistent, print 'Correct' (without the quotes). Otherwise, print 'Incorrect' (without the quotes).
Examples
Input
2 1 1 2
1
Output
Correct
Input
3 1 1 3
2
Output
Correct
Input
2 1 1 3
2
Output
Incorrect
Note
In the first test sample one of the possible initial configurations of temperatures is [1, 2].
In the second test sample one of the possible initial configurations of temperatures is [2, 1, 3].
In the third test sample it is impossible to add one temperature to obtain the minimum equal to 1 and the maximum equal to 3. | def main():
n, m, mn, mx = map(int, input().split())
A = list(map(int, input().split()))
a = min(A)
b = max(A)
if a < mn or b > mx:
print("Incorrect")
return
cnt = 0
if a > mn:
cnt += 1
if b < mx:
cnt += 1
if m + cnt <= n:
print("Correct")
else:
print("Incorrect")
main() | {
"input": [
"2 1 1 3\n2\n",
"2 1 1 2\n1\n",
"3 1 1 3\n2\n"
],
"output": [
"Incorrect\n",
"Correct\n",
"Correct\n"
]
} |
2,038 | 9 | Vasya thinks that lucky tickets are the tickets whose numbers are divisible by 3. He gathered quite a large collection of such tickets but one day his younger brother Leonid was having a sulk and decided to destroy the collection. First he tore every ticket exactly in two, but he didnβt think it was enough and Leonid also threw part of the pieces away. Having seen this, Vasya got terrified but still tried to restore the collection. He chose several piece pairs and glued each pair together so that each pair formed a lucky ticket. The rest of the pieces Vasya threw away reluctantly. Thus, after the gluing of the 2t pieces he ended up with t tickets, each of which was lucky.
When Leonid tore the tickets in two pieces, one piece contained the first several letters of his number and the second piece contained the rest.
Vasya can glue every pair of pieces in any way he likes, but it is important that he gets a lucky ticket in the end. For example, pieces 123 and 99 can be glued in two ways: 12399 and 99123.
What maximum number of tickets could Vasya get after that?
Input
The first line contains integer n (1 β€ n β€ 104) β the number of pieces. The second line contains n space-separated numbers ai (1 β€ ai β€ 108) β the numbers on the pieces. Vasya can only glue the pieces in pairs. Even if the number of a piece is already lucky, Vasya should glue the piece with some other one for it to count as lucky. Vasya does not have to use all the pieces. The numbers on the pieces an on the resulting tickets may coincide.
Output
Print the single number β the maximum number of lucky tickets that will be able to be restored. Don't forget that every lucky ticket is made of exactly two pieces glued together.
Examples
Input
3
123 123 99
Output
1
Input
6
1 1 1 23 10 3
Output
1 | from sys import *
inp = lambda : stdin.readline()
def main():
n = int(inp())
l = map(int,inp().split())
d = [0,0,0]
for i in l:
d[(i+3)%3] += 1
ans = d[0]//2 + min(d[1],d[2])
print(ans)
if __name__ == "__main__":
main() | {
"input": [
"3\n123 123 99\n",
"6\n1 1 1 23 10 3\n"
],
"output": [
"1\n",
"1\n"
]
} |
2,039 | 10 | Vasya had two arrays consisting of non-negative integers: a of size n and b of size m. Vasya chose a positive integer k and created an n Γ m matrix v using the following formula:
<image>
Vasya wrote down matrix v on a piece of paper and put it in the table.
A year later Vasya was cleaning his table when he found a piece of paper containing an n Γ m matrix w. He remembered making a matrix one day by the rules given above but he was not sure if he had found the paper with the matrix v from those days. Your task is to find out if the matrix w that you've found could have been obtained by following these rules and if it could, then for what numbers k, a1, a2, ..., an, b1, b2, ..., bm it is possible.
Input
The first line contains integers n and m (1 β€ n, m β€ 100), separated by a space β the number of rows and columns in the found matrix, respectively.
The i-th of the following lines contains numbers wi, 1, wi, 2, ..., wi, m (0 β€ wi, j β€ 109), separated by spaces β the elements of the i-th row of matrix w.
Output
If the matrix w could not have been obtained in the manner described above, print "NO" (without quotes) in the single line of output.
Otherwise, print four lines.
In the first line print "YES" (without quotes).
In the second line print an integer k (1 β€ k β€ 1018). Note that each element of table w should be in range between 0 and k - 1 inclusively.
In the third line print n integers a1, a2, ..., an (0 β€ ai β€ 1018), separated by spaces.
In the fourth line print m integers b1, b2, ..., bm (0 β€ bi β€ 1018), separated by spaces.
Examples
Input
2 3
1 2 3
2 3 4
Output
YES
1000000007
0 1
1 2 3
Input
2 2
1 2
2 0
Output
YES
3
0 1
1 2
Input
2 2
1 2
2 1
Output
NO
Note
By <image> we denote the remainder of integer division of b by c.
It is guaranteed that if there exists some set of numbers k, a1, ..., an, b1, ..., bm, that you could use to make matrix w, then there also exists a set of numbers that meets the limits 1 β€ k β€ 1018, 1 β€ ai β€ 1018, 1 β€ bi β€ 1018 in the output format. In other words, these upper bounds are introduced only for checking convenience purposes. | def main():
n, m = map(int, input().split())
l = list(tuple(map(int, input().split())) for _ in range(n))
ma = max(x for _ in l for x in _)
bb = l[0]
x = bb[0]
aa = [_[0] - x for _ in l]
err = set(map(abs, filter(None, (a + b - x for a, row in zip(aa, l) for b, x in zip(bb, row)))))
if err:
k = err.pop()
if err or k <= ma:
print('NO')
return
else:
k = ma + 1
for i in range(n):
aa[i] %= k
print('YES')
print(k)
print(*aa)
print(*bb)
if __name__ == '__main__':
main()
| {
"input": [
"2 2\n1 2\n2 1\n",
"2 2\n1 2\n2 0\n",
"2 3\n1 2 3\n2 3 4\n"
],
"output": [
"NO\n",
"YES\n3\n0 1 \n1 2 \n",
"YES\n5\n0 1 \n1 2 3 \n"
]
} |
2,040 | 9 | Marina loves strings of the same length and Vasya loves when there is a third string, different from them in exactly t characters. Help Vasya find at least one such string.
More formally, you are given two strings s1, s2 of length n and number t. Let's denote as f(a, b) the number of characters in which strings a and b are different. Then your task will be to find any string s3 of length n, such that f(s1, s3) = f(s2, s3) = t. If there is no such string, print - 1.
Input
The first line contains two integers n and t (1 β€ n β€ 105, 0 β€ t β€ n).
The second line contains string s1 of length n, consisting of lowercase English letters.
The third line contain string s2 of length n, consisting of lowercase English letters.
Output
Print a string of length n, differing from string s1 and from s2 in exactly t characters. Your string should consist only from lowercase English letters. If such string doesn't exist, print -1.
Examples
Input
3 2
abc
xyc
Output
ayd
Input
1 0
c
b
Output
-1 | n, t = map(int, input().split())
a, b = input(), input()
ans = []
s = d = 0
for i, j in zip(a, b):
if i == j:
s += 1
else:
d += 1
if t < (d + 1) // 2:
print(-1)
exit()
x = min(n - t, s)
y = z = max(n - t - s, 0)
def f(a, b):
for i in range(97, 123):
if chr(i) not in [a, b]:
return chr(i)
for i in range(n):
if a[i] == b[i]:
if x:
ans.append(a[i])
x -= 1
else:
ans.append(f(a[i], b[i]))
else:
if y:
ans.append(a[i])
y -= 1
elif z:
ans.append(b[i])
z -= 1
else:
ans.append(f(a[i], b[i]))
print(''.join(ans)) | {
"input": [
"1 0\nc\nb\n",
"3 2\nabc\nxyc\n"
],
"output": [
"-1",
"bac\n"
]
} |
2,041 | 9 | An infinitely long railway has a train consisting of n cars, numbered from 1 to n (the numbers of all the cars are distinct) and positioned in arbitrary order. David Blaine wants to sort the railway cars in the order of increasing numbers. In one move he can make one of the cars disappear from its place and teleport it either to the beginning of the train, or to the end of the train, at his desire. What is the minimum number of actions David Blaine needs to perform in order to sort the train?
Input
The first line of the input contains integer n (1 β€ n β€ 100 000) β the number of cars in the train.
The second line contains n integers pi (1 β€ pi β€ n, pi β pj if i β j) β the sequence of the numbers of the cars in the train.
Output
Print a single integer β the minimum number of actions needed to sort the railway cars.
Examples
Input
5
4 1 2 5 3
Output
2
Input
4
4 1 3 2
Output
2
Note
In the first sample you need first to teleport the 4-th car, and then the 5-th car to the end of the train. | def li(kkk,n):
lis = [0]*(n+1)
lis[0]=0
for i in range (0 , n):
lis[kkk[i]]=lis[kkk[i]-1]+1
# print(lis)
return max(lis)
n = int(input())
kkk= list(map(int,input().split()))
ans = li(kkk,n)
print(n-ans) | {
"input": [
"5\n4 1 2 5 3\n",
"4\n4 1 3 2\n"
],
"output": [
"2",
"2"
]
} |
2,042 | 9 | Limak is a little polar bear. He likes nice strings β strings of length n, consisting of lowercase English letters only.
The distance between two letters is defined as the difference between their positions in the alphabet. For example, <image>, and <image>.
Also, the distance between two nice strings is defined as the sum of distances of corresponding letters. For example, <image>, and <image>.
Limak gives you a nice string s and an integer k. He challenges you to find any nice string s' that <image>. Find any s' satisfying the given conditions, or print "-1" if it's impossible to do so.
As input/output can reach huge size it is recommended to use fast input/output methods: for example, prefer to use gets/scanf/printf instead of getline/cin/cout in C++, prefer to use BufferedReader/PrintWriter instead of Scanner/System.out in Java.
Input
The first line contains two integers n and k (1 β€ n β€ 105, 0 β€ k β€ 106).
The second line contains a string s of length n, consisting of lowercase English letters.
Output
If there is no string satisfying the given conditions then print "-1" (without the quotes).
Otherwise, print any nice string s' that <image>.
Examples
Input
4 26
bear
Output
roar
Input
2 7
af
Output
db
Input
3 1000
hey
Output
-1 | n, k = map(int, input().split())
s = list(input())
def dist(a, b):
return abs(ord(a) - ord(b))
for i in range(n):
if k > 0:
dz, da = dist(s[i], 'z'), dist(s[i], 'a')
if dz > da:
s[i] = chr(min(ord('z'), ord(s[i]) + k))
k -= dz
else:
s[i] = chr(max(ord('a'), ord(s[i]) - k))
k -= da
print(-1 if k > 0 else ''.join(s))
| {
"input": [
"4 26\nbear\n",
"2 7\naf\n",
"3 1000\nhey\n"
],
"output": [
"zgar",
"hf",
"-1"
]
} |
2,043 | 10 | You are given n segments on a line. There are no ends of some segments that coincide. For each segment find the number of segments it contains.
Input
The first line contains a single integer n (1 β€ n β€ 2Β·105) β the number of segments on a line.
Each of the next n lines contains two integers li and ri ( - 109 β€ li < ri β€ 109) β the coordinates of the left and the right ends of the i-th segment. It is guaranteed that there are no ends of some segments that coincide.
Output
Print n lines. The j-th of them should contain the only integer aj β the number of segments contained in the j-th segment.
Examples
Input
4
1 8
2 3
4 7
5 6
Output
3
0
1
0
Input
3
3 4
1 5
2 6
Output
0
1
1 | from sys import stdin
input=stdin.readline
class BIT():
def __init__(self, n):
self.n = n
self.tree = [0] * (n + 1)
def sum(self, i):
ans = 0
i += 1
while i > 0:
ans += self.tree[i]
i -= (i & (-i))
return ans
def update(self, i, value):
i += 1
while i <= self.n:
self.tree[i] += value
i += (i & (-i))
def common():
n = int(input())
left=[0]*(n)
right=[0]*(n)
for i in range(n):
a, b = map(int, input().strip().split())
left[i]=a
right[i]=b
order=list(range(n))
order=sorted(order,key=lambda s:left[s])
for i in range(n):
left[order[i]]=i #chota pehle
order = list(range(n))
order = sorted(order, key=lambda s: right[s])
ft=BIT(n)
res=[0]*(n)
for i,k in enumerate(order):
a=left[k]
res[k]=i-ft.sum(a-1) #kitne bade lodu isse chote the - kitne chotu lodu
ft.update(a,1)
print(*res,sep="\n")
common()
| {
"input": [
"4\n1 8\n2 3\n4 7\n5 6\n",
"3\n3 4\n1 5\n2 6\n"
],
"output": [
"3\n0\n1\n0\n",
"0\n1\n1\n"
]
} |
2,044 | 8 | The girl Taylor has a beautiful calendar for the year y. In the calendar all days are given with their days of week: Monday, Tuesday, Wednesday, Thursday, Friday, Saturday and Sunday.
The calendar is so beautiful that she wants to know what is the next year after y when the calendar will be exactly the same. Help Taylor to find that year.
Note that leap years has 366 days. The year is leap if it is divisible by 400 or it is divisible by 4, but not by 100 (<https://en.wikipedia.org/wiki/Leap_year>).
Input
The only line contains integer y (1000 β€ y < 100'000) β the year of the calendar.
Output
Print the only integer y' β the next year after y when the calendar will be the same. Note that you should find the first year after y with the same calendar.
Examples
Input
2016
Output
2044
Input
2000
Output
2028
Input
50501
Output
50507
Note
Today is Monday, the 13th of June, 2016. | def vis(n):
return 2 if (n%4==0 and n%100) or n%400==0 else 1
n,o=int(input()),0
nn=n
while True:
o+=vis(n)
n+=1
if o%7==0 and vis(n)==vis(nn): break
print(n) | {
"input": [
"2000\n",
"50501\n",
"2016\n"
],
"output": [
"2028",
"50507",
"2044"
]
} |
2,045 | 8 | Treeland is a country in which there are n towns connected by n - 1 two-way road such that it's possible to get from any town to any other town.
In Treeland there are 2k universities which are located in different towns.
Recently, the president signed the decree to connect universities by high-speed network.The Ministry of Education understood the decree in its own way and decided that it was enough to connect each university with another one by using a cable. Formally, the decree will be done!
To have the maximum sum in the budget, the Ministry decided to divide universities into pairs so that the total length of the required cable will be maximum. In other words, the total distance between universities in k pairs should be as large as possible.
Help the Ministry to find the maximum total distance. Of course, each university should be present in only one pair. Consider that all roads have the same length which is equal to 1.
Input
The first line of the input contains two integers n and k (2 β€ n β€ 200 000, 1 β€ k β€ n / 2) β the number of towns in Treeland and the number of university pairs. Consider that towns are numbered from 1 to n.
The second line contains 2k distinct integers u1, u2, ..., u2k (1 β€ ui β€ n) β indices of towns in which universities are located.
The next n - 1 line contains the description of roads. Each line contains the pair of integers xj and yj (1 β€ xj, yj β€ n), which means that the j-th road connects towns xj and yj. All of them are two-way roads. You can move from any town to any other using only these roads.
Output
Print the maximum possible sum of distances in the division of universities into k pairs.
Examples
Input
7 2
1 5 6 2
1 3
3 2
4 5
3 7
4 3
4 6
Output
6
Input
9 3
3 2 1 6 5 9
8 9
3 2
2 7
3 4
7 6
4 5
2 1
2 8
Output
9
Note
The figure below shows one of possible division into pairs in the first test. If you connect universities number 1 and 6 (marked in red) and universities number 2 and 5 (marked in blue) by using the cable, the total distance will equal 6 which will be the maximum sum in this example.
<image> | def main():
n, k = map(int, input().split())
s = [0] * n
for i in map(int, input().split()):
s[i - 1] = 1
e = [[] for _ in range(n)]
for _ in range(n - 1):
x, y = (int(s) - 1 for s in input().split())
e[x].append(y)
e[y].append(x)
q, fa = [0], [-1] * n
fa[0] = 0
for i in range(n):
x = q[i]
for y in e[x]:
if fa[y] == -1:
fa[y] = x
q.append(y)
dp, k2 = [0] * n, k * 2
for x in reversed(q):
for y in e[x]:
if fa[y] == x:
i = s[y]
s[x] += i
dp[x] += dp[y] + (k2 - i if i > k else i)
print(dp[0])
if __name__ == "__main__":
main()
| {
"input": [
"9 3\n3 2 1 6 5 9\n8 9\n3 2\n2 7\n3 4\n7 6\n4 5\n2 1\n2 8\n",
"7 2\n1 5 6 2\n1 3\n3 2\n4 5\n3 7\n4 3\n4 6\n"
],
"output": [
"9\n",
"6\n"
]
} |
2,046 | 10 | You are given a set Y of n distinct positive integers y1, y2, ..., yn.
Set X of n distinct positive integers x1, x2, ..., xn is said to generate set Y if one can transform X to Y by applying some number of the following two operation to integers in X:
1. Take any integer xi and multiply it by two, i.e. replace xi with 2Β·xi.
2. Take any integer xi, multiply it by two and add one, i.e. replace xi with 2Β·xi + 1.
Note that integers in X are not required to be distinct after each operation.
Two sets of distinct integers X and Y are equal if they are equal as sets. In other words, if we write elements of the sets in the array in the increasing order, these arrays would be equal.
Note, that any set of integers (or its permutation) generates itself.
You are given a set Y and have to find a set X that generates Y and the maximum element of X is mininum possible.
Input
The first line of the input contains a single integer n (1 β€ n β€ 50 000) β the number of elements in Y.
The second line contains n integers y1, ..., yn (1 β€ yi β€ 109), that are guaranteed to be distinct.
Output
Print n integers β set of distinct integers that generate Y and the maximum element of which is minimum possible. If there are several such sets, print any of them.
Examples
Input
5
1 2 3 4 5
Output
4 5 2 3 1
Input
6
15 14 3 13 1 12
Output
12 13 14 7 3 1
Input
6
9 7 13 17 5 11
Output
4 5 2 6 3 1 | def main():
from heapq import heapify, heapreplace
input()
s = set(map(int, input().split()))
xx = [-x for x in s]
heapify(xx)
while True:
x = -xx[0]
while x != 1:
x //= 2
if x not in s:
s.add(x)
heapreplace(xx, -x)
break
else:
break
print(' '.join(str(-x) for x in xx))
if __name__ == '__main__':
main()
| {
"input": [
"6\n9 7 13 17 5 11\n",
"5\n1 2 3 4 5\n",
"6\n15 14 3 13 1 12\n"
],
"output": [
"1 2 3 4 5 6 \n",
"1 2 3 4 5 \n",
"1 3 7 12 13 14 \n"
]
} |
2,047 | 8 | This is an interactive problem. In the interaction section below you will see the information about flushing the output.
In this problem, you will be playing a game with Hongcow. How lucky of you!
Hongcow has a hidden n by n matrix M. Let Mi, j denote the entry i-th row and j-th column of the matrix. The rows and columns are labeled from 1 to n.
The matrix entries are between 0 and 109. In addition, Mi, i = 0 for all valid i. Your task is to find the minimum value along each row, excluding diagonal elements. Formally, for each i, you must find <image>.
To do this, you can ask Hongcow some questions.
A question consists of giving Hongcow a subset of distinct indices {w1, w2, ..., wk}, with 1 β€ k β€ n. Hongcow will respond with n integers. The i-th integer will contain the minimum value of min1 β€ j β€ kMi, wj.
You may only ask Hongcow at most 20 questions β he thinks you only need that many questions answered.
When you are ready to answer, print out a single integer - 1 on its own line, then n integers on the next line. The i-th integer should be the minimum value in the i-th row of the matrix, excluding the i-th element. Do not forget to flush the final answer as well. Printing the answer does not count as asking a question.
You will get Wrong Answer verdict if
* Your question or answers are not in the format described in this statement.
* You ask strictly more than 20 questions.
* Your question contains duplicate indices.
* The value of k in your question does not lie in the range from 1 to n, inclusive.
* Your final answer is not correct.
You will get Idleness Limit Exceeded if you don't print anything or if you forget to flush the output, including for the final answer (more info about flushing output below).
Input
The first line of input will contain a single integer n (2 β€ n β€ 1, 000).
Output
To print the final answer, print out the string -1 on its own line. Then, the next line should contain n integers. The i-th integer should be the minimum value of the i-th row of the matrix, excluding elements on the diagonal. Do not forget to flush your answer!
Interaction
To ask a question, print out a single integer k on its own line, denoting the size of your subset. Then, the next line should contain k integers w1, w2, ... wk. Note, you must flush your output to get a response.
Hongcow will respond by printing out a line with n integers. The i-th integer in this line represents the minimum value of Mi, wj where j is between 1 and k.
You may only ask a question at most 20 times, otherwise, you will get Wrong Answer.
To flush you can use (just after printing an integer and end-of-line):
* fflush(stdout) in C++;
* System.out.flush() in Java;
* stdout.flush() in Python;
* flush(output) in Pascal;
* See the documentation for other languages.
Hacking To hack someone, use the following format
n
M_{1,1} M_{1,2} ... M_{1,n}
M_{2,1} M_{2,2} ... M_{2,n}
...
M_{n,1} M_{n,2} ... M_{n,n}
Of course, contestant programs will not be able to see this input.
Examples
Input
3
0 0 0
2 7 0
0 0 4
3 0 8
0 5 4
Output
3
1 2 3
1
3
2
1 2
1
2
1
1
-1
2 5 4
Input
2
0 0
0 0
Output
1
2
1
1
-1
0 0
Note
In the first sample, Hongcow has the hidden matrix
[
[0, 3, 2],
[5, 0, 7],
[4, 8 ,0],
]
Here is a more readable version demonstrating the interaction. The column on the left represents Hongcow, while the column on the right represents the contestant.
3
3
1 2 3
0 0 0
1
3
2 7 0
2
1 2
0 0 4
1
2
3 0 8
1
1
0 5 4
-1
2 5 4
For the second sample, it is possible for off-diagonal elements of the matrix to be zero. | from sys import stdout
def g(k, p):
print(str(k) + '\n' + ' '.join(map(str, p)))
stdout.flush()
n = int(input())
s = [9e9] * n
def f(q):
global s
p = [k + 1 for k, v in enumerate(q) if v]
g(len(p), p)
s = [i if j else min(i, int(k)) for i, j, k in zip(s, q, input().split())]
return [not v for v in q]
k = 1
while k < n:
f(f([not (i & k) for i in range(n)]))
k *= 2
g(-1, s) | {
"input": [
"2\n0 0\n0 0",
"3\n0 0 0\n2 7 0\n0 0 4\n3 0 8\n0 5 4"
],
"output": [
"1\n1 \n1\n2 \n-1\n0 0 ",
"2\n1 3 \n1\n2 \n2\n1 2 \n1\n3 \n-1\n2 0 0 "
]
} |
2,048 | 9 | In the army, it isn't easy to form a group of soldiers that will be effective on the battlefield. The communication is crucial and thus no two soldiers should share a name (what would happen if they got an order that Bob is a scouter, if there are two Bobs?).
A group of soldiers is effective if and only if their names are different. For example, a group (John, Bob, Limak) would be effective, while groups (Gary, Bob, Gary) and (Alice, Alice) wouldn't.
You are a spy in the enemy's camp. You noticed n soldiers standing in a row, numbered 1 through n. The general wants to choose a group of k consecutive soldiers. For every k consecutive soldiers, the general wrote down whether they would be an effective group or not.
You managed to steal the general's notes, with n - k + 1 strings s1, s2, ..., sn - k + 1, each either "YES" or "NO".
* The string s1 describes a group of soldiers 1 through k ("YES" if the group is effective, and "NO" otherwise).
* The string s2 describes a group of soldiers 2 through k + 1.
* And so on, till the string sn - k + 1 that describes a group of soldiers n - k + 1 through n.
Your task is to find possible names of n soldiers. Names should match the stolen notes. Each name should be a string that consists of between 1 and 10 English letters, inclusive. The first letter should be uppercase, and all other letters should be lowercase. Names don't have to be existing names β it's allowed to print "Xyzzzdj" or "T" for example.
Find and print any solution. It can be proved that there always exists at least one solution.
Input
The first line of the input contains two integers n and k (2 β€ k β€ n β€ 50) β the number of soldiers and the size of a group respectively.
The second line contains n - k + 1 strings s1, s2, ..., sn - k + 1. The string si is "YES" if the group of soldiers i through i + k - 1 is effective, and "NO" otherwise.
Output
Find any solution satisfying all given conditions. In one line print n space-separated strings, denoting possible names of soldiers in the order. The first letter of each name should be uppercase, while the other letters should be lowercase. Each name should contain English letters only and has length from 1 to 10.
If there are multiple valid solutions, print any of them.
Examples
Input
8 3
NO NO YES YES YES NO
Output
Adam Bob Bob Cpqepqwer Limak Adam Bob Adam
Input
9 8
YES NO
Output
R Q Ccccccccc Ccocc Ccc So Strong Samples Ccc
Input
3 2
NO NO
Output
Na Na Na
Note
In the first sample, there are 8 soldiers. For every 3 consecutive ones we know whether they would be an effective group. Let's analyze the provided sample output:
* First three soldiers (i.e. Adam, Bob, Bob) wouldn't be an effective group because there are two Bobs. Indeed, the string s1 is "NO".
* Soldiers 2 through 4 (Bob, Bob, Cpqepqwer) wouldn't be effective either, and the string s2 is "NO".
* Soldiers 3 through 5 (Bob, Cpqepqwer, Limak) would be effective, and the string s3 is "YES".
* ...,
* Soldiers 6 through 8 (Adam, Bob, Adam) wouldn't be effective, and the string s6 is "NO". | def main():
n, k = map(int, input().split())
res = ['AB'[i // 26] + chr(97 + i % 26) for i in range(n)]
for i, w in enumerate(input().split()):
if w == 'NO':
res[i + k - 1] = res[i]
print(*res)
if __name__ == '__main__':
main()
| {
"input": [
"3 2\nNO NO\n",
"9 8\nYES NO\n",
"8 3\nNO NO YES YES YES NO\n"
],
"output": [
"A A A ",
"A B C D E F G H B ",
"A B A B E F G F "
]
} |
2,049 | 9 | Beroffice text editor has a wide range of features that help working with text. One of the features is an automatic search for typos and suggestions of how to fix them.
Beroffice works only with small English letters (i.e. with 26 letters from a to z). Beroffice thinks that a word is typed with a typo if there are three or more consonants in a row in the word. The only exception is that if the block of consonants has all letters the same, then this block (even if its length is greater than three) is not considered a typo. Formally, a word is typed with a typo if there is a block of not less that three consonants in a row, and there are at least two different letters in this block.
For example:
* the following words have typos: "hellno", "hackcerrs" and "backtothefutttture";
* the following words don't have typos: "helllllooooo", "tobeornottobe" and "oooooo".
When Beroffice editor finds a word with a typo, it inserts as little as possible number of spaces in this word (dividing it into several words) in such a way that each of the resulting words is typed without any typos.
Implement this feature of Beroffice editor. Consider the following letters as the only vowels: 'a', 'e', 'i', 'o' and 'u'. All the other letters are consonants in this problem.
Input
The only line contains a non-empty word consisting of small English letters. The length of the word is between 1 and 3000 letters.
Output
Print the given word without any changes if there are no typos.
If there is at least one typo in the word, insert the minimum number of spaces into the word so that each of the resulting words doesn't have any typos. If there are multiple solutions, print any of them.
Examples
Input
hellno
Output
hell no
Input
abacaba
Output
abacaba
Input
asdfasdf
Output
asd fasd f | def gl(x):
return x not in ['e', 'u', 'i', 'o', 'a']
s = input()
o = 0
print(s[:2], end = '')
for i in range(2, len(s)):
if gl(s[i - 2]) and gl(s[i - 1]) and gl(s[i]) and (s[i - 2] != s[i - 1] or s[i - 1] != s[i]) and o + 1 < i:
print(' ', end = '')
o = i
print(s[i], sep = '', end = '') | {
"input": [
"abacaba\n",
"asdfasdf\n",
"hellno\n"
],
"output": [
"abacaba\n",
"asd fasd f\n",
"hell no\n"
]
} |
2,050 | 10 | Students went into a class to write a test and sat in some way. The teacher thought: "Probably they sat in this order to copy works of each other. I need to rearrange them in such a way that students that were neighbors are not neighbors in a new seating."
The class can be represented as a matrix with n rows and m columns with a student in each cell. Two students are neighbors if cells in which they sit have a common side.
Let's enumerate students from 1 to nΒ·m in order of rows. So a student who initially sits in the cell in row i and column j has a number (i - 1)Β·m + j. You have to find a matrix with n rows and m columns in which all numbers from 1 to nΒ·m appear exactly once and adjacent numbers in the original matrix are not adjacent in it, or determine that there is no such matrix.
Input
The only line contains two integers n and m (1 β€ n, m β€ 105; nΒ·m β€ 105) β the number of rows and the number of columns in the required matrix.
Output
If there is no such matrix, output "NO" (without quotes).
Otherwise in the first line output "YES" (without quotes), and in the next n lines output m integers which form the required matrix.
Examples
Input
2 4
Output
YES
5 4 7 2
3 6 1 8
Input
2 1
Output
NO
Note
In the first test case the matrix initially looks like this:
1 2 3 4
5 6 7 8
It's easy to see that there are no two students that are adjacent in both matrices.
In the second test case there are only two possible seatings and in both of them students with numbers 1 and 2 are neighbors. | def transpos(a,n,m):
b = []
for i in range(m):
b.append([a[j][i] for j in range(n)])
return(b)
def printarr(a):
for i in range(len(a)):
for j in range(len(a[i])):
print(a[i][j], end = ' ')
print("")
n,m = [int(i) for i in input().split()]
a = []
for i in range(n):
a.append([i*m + j for j in range(1,m+1)])
#printarr(transpos(a,n,m))
transp_flag = False
if n > m:
tmp = m
m = n
n = tmp
a = transpos(a,m,n)
transp_flag = True
# m >= n
if m < 3 and m != 1:
print("NO")
elif m == 1:
print("YES")
print(1)
else:
if m == 3:
if n < 3: print("NO")
else:
print("YES")
printarr([[5,9,3],[7,2,4],[1,6,8]])
elif m == 4:
for i in range(n):
tmp = a[i][:]
if i%2 == 0:
a[i] = [tmp[1],tmp[3],tmp[0],tmp[2]]
else:
a[i] = [tmp[2],tmp[0],tmp[3],tmp[1]]
else:
for i in range(n):
if i%2 == 0:
tmp1 = [a[i][j] for j in range(m) if j%2 == 0]
tmp2 = [a[i][j] for j in range(m) if j%2 == 1]
if i%2 == 1:
tmp1 = [a[i][j] for j in range(m) if j%2 == 1]
tmp2 = [a[i][j] for j in range(m) if j%2 == 0]
a[i] = tmp1 + tmp2
if m > 3:
if transp_flag: a = transpos(a,n,m)
print("YES")
printarr(a)
| {
"input": [
"2 1\n",
"2 4\n"
],
"output": [
"NO\n",
"YES\n2 4 1 3 \n7 5 8 6 \n"
]
} |
2,051 | 7 | When registering in a social network, users are allowed to create their own convenient login to make it easier to share contacts, print it on business cards, etc.
Login is an arbitrary sequence of lower and uppercase latin letters, digits and underline symbols (Β«_Β»). However, in order to decrease the number of frauds and user-inattention related issues, it is prohibited to register a login if it is similar with an already existing login. More precisely, two logins s and t are considered similar if we can transform s to t via a sequence of operations of the following types:
* transform lowercase letters to uppercase and vice versa;
* change letter Β«OΒ» (uppercase latin letter) to digit Β«0Β» and vice versa;
* change digit Β«1Β» (one) to any letter among Β«lΒ» (lowercase latin Β«LΒ»), Β«IΒ» (uppercase latin Β«iΒ») and vice versa, or change one of these letters to other.
For example, logins Β«CodeforcesΒ» and Β«codef0rcesΒ» as well as Β«OO0OOO00O0OOO0O00OOO0OO_lolΒ» and Β«OO0OOO0O00OOO0O00OO0OOO_1oIΒ» are considered similar whereas Β«CodeforcesΒ» and Β«Code_forcesΒ» are not.
You're given a list of existing logins with no two similar amonst and a newly created user login. Check whether this new login is similar with any of the existing ones.
Input
The first line contains a non-empty string s consisting of lower and uppercase latin letters, digits and underline symbols (Β«_Β») with length not exceeding 50 β the login itself.
The second line contains a single integer n (1 β€ n β€ 1 000) β the number of existing logins.
The next n lines describe the existing logins, following the same constraints as the user login (refer to the first line of the input). It's guaranteed that no two existing logins are similar.
Output
Print Β«YesΒ» (without quotes), if user can register via this login, i.e. none of the existing logins is similar with it.
Otherwise print Β«NoΒ» (without quotes).
Examples
Input
1_wat
2
2_wat
wat_1
Output
Yes
Input
000
3
00
ooA
oOo
Output
No
Input
_i_
3
__i_
_1_
I
Output
No
Input
La0
3
2a0
La1
1a0
Output
No
Input
abc
1
aBc
Output
No
Input
0Lil
2
LIL0
0Ril
Output
Yes
Note
In the second sample case the user wants to create a login consisting of three zeros. It's impossible due to collision with the third among the existing.
In the third sample case the new login is similar with the second one. | def f(s):
return s.lower().replace('1', 'l').replace('0', 'o').replace('i', 'l')
s = f(input())
n = int(input())
l = {f(input()) for _ in range(n)}
print('No' if s in l else 'Yes')
| {
"input": [
"000\n3\n00\nooA\noOo\n",
"1_wat\n2\n2_wat\nwat_1\n",
"_i_\n3\n__i_\n_1_\nI\n",
"0Lil\n2\nLIL0\n0Ril\n",
"abc\n1\naBc\n",
"La0\n3\n2a0\nLa1\n1a0\n"
],
"output": [
"No\n",
"Yes\n",
"No\n",
"Yes\n",
"No\n",
"No\n"
]
} |
2,052 | 9 | An atom of element X can exist in n distinct states with energies E1 < E2 < ... < En. Arkady wants to build a laser on this element, using a three-level scheme. Here is a simplified description of the scheme.
Three distinct states i, j and k are selected, where i < j < k. After that the following process happens:
1. initially the atom is in the state i,
2. we spend Ek - Ei energy to put the atom in the state k,
3. the atom emits a photon with useful energy Ek - Ej and changes its state to the state j,
4. the atom spontaneously changes its state to the state i, losing energy Ej - Ei,
5. the process repeats from step 1.
Let's define the energy conversion efficiency as <image>, i. e. the ration between the useful energy of the photon and spent energy.
Due to some limitations, Arkady can only choose such three states that Ek - Ei β€ U.
Help Arkady to find such the maximum possible energy conversion efficiency within the above constraints.
Input
The first line contains two integers n and U (3 β€ n β€ 105, 1 β€ U β€ 109) β the number of states and the maximum possible difference between Ek and Ei.
The second line contains a sequence of integers E1, E2, ..., En (1 β€ E1 < E2... < En β€ 109). It is guaranteed that all Ei are given in increasing order.
Output
If it is not possible to choose three states that satisfy all constraints, print -1.
Otherwise, print one real number Ξ· β the maximum possible energy conversion efficiency. Your answer is considered correct its absolute or relative error does not exceed 10 - 9.
Formally, let your answer be a, and the jury's answer be b. Your answer is considered correct if <image>.
Examples
Input
4 4
1 3 5 7
Output
0.5
Input
10 8
10 13 15 16 17 19 20 22 24 25
Output
0.875
Input
3 1
2 5 10
Output
-1
Note
In the first example choose states 1, 2 and 3, so that the energy conversion efficiency becomes equal to <image>.
In the second example choose states 4, 5 and 9, so that the energy conversion efficiency becomes equal to <image>. | import sys
def read_two_int():
return map(int, sys.stdin.readline().strip().split(' '))
def fast_solution(n, U, E):
best = -1
R = 2
for i in range(n-2):
# move R forcefully
R = max(R, i+2)
while (R + 1 < n) and (E[R+1] - E[i] <= U):
R += 1
if E[R] - E[i] <= U:
efficiency = float(E[R] - E[i+1]) / (E[R] - E[i])
if best is None or efficiency > best:
best = efficiency
return best
n, U = read_two_int()
E = list(read_two_int())
print(fast_solution(n, U, E))
| {
"input": [
"10 8\n10 13 15 16 17 19 20 22 24 25\n",
"4 4\n1 3 5 7\n",
"3 1\n2 5 10\n"
],
"output": [
"0.8750000000",
"0.5000000000",
"-1"
]
} |
2,053 | 9 | You're given a tree with n vertices.
Your task is to determine the maximum possible number of edges that can be removed in such a way that all the remaining connected components will have even size.
Input
The first line contains an integer n (1 β€ n β€ 10^5) denoting the size of the tree.
The next n - 1 lines contain two integers u, v (1 β€ u, v β€ n) each, describing the vertices connected by the i-th edge.
It's guaranteed that the given edges form a tree.
Output
Output a single integer k β the maximum number of edges that can be removed to leave all connected components with even size, or -1 if it is impossible to remove edges in order to satisfy this property.
Examples
Input
4
2 4
4 1
3 1
Output
1
Input
3
1 2
1 3
Output
-1
Input
10
7 1
8 4
8 10
4 7
6 5
9 3
3 5
2 10
2 5
Output
4
Input
2
1 2
Output
0
Note
In the first example you can remove the edge between vertices 1 and 4. The graph after that will have two connected components with two vertices in each.
In the second example you can't remove edges in such a way that all components have even number of vertices, so the answer is -1. | import sys,collections
input = sys.stdin.readline
def bfs(adj_list,n):
c=[1]*n;v=[-1]*n;v[0]=0;q=[0]
while q:
x=q[-1];flag=False
for to in adj_list[x]:
if v[to]==-1:
v[to]=x
q.append(to)
flag=True
if not flag:
q.pop()
c[v[x]]+=c[x]
ans=0
for i in c[1:]:
if i&1==0:ans+=1
print(ans)
n=int(input())
if n%2==1:print(-1);exit()
adj_list=[[]for _ in range(n+10)]
for _ in range(n-1):
a,b=map(int,input().split())
a-=1;b-=1
adj_list[a].append(b)
adj_list[b].append(a)
bfs(adj_list,n)
| {
"input": [
"4\n2 4\n4 1\n3 1\n",
"2\n1 2\n",
"10\n7 1\n8 4\n8 10\n4 7\n6 5\n9 3\n3 5\n2 10\n2 5\n",
"3\n1 2\n1 3\n"
],
"output": [
"1\n",
"0\n",
"4\n",
"-1\n"
]
} |
2,054 | 7 | Natasha is going to fly on a rocket to Mars and return to Earth. Also, on the way to Mars, she will land on n - 2 intermediate planets. Formally: we number all the planets from 1 to n. 1 is Earth, n is Mars. Natasha will make exactly n flights: 1 β 2 β β¦ n β 1.
Flight from x to y consists of two phases: take-off from planet x and landing to planet y. This way, the overall itinerary of the trip will be: the 1-st planet β take-off from the 1-st planet β landing to the 2-nd planet β 2-nd planet β take-off from the 2-nd planet β β¦ β landing to the n-th planet β the n-th planet β take-off from the n-th planet β landing to the 1-st planet β the 1-st planet.
The mass of the rocket together with all the useful cargo (but without fuel) is m tons. However, Natasha does not know how much fuel to load into the rocket. Unfortunately, fuel can only be loaded on Earth, so if the rocket runs out of fuel on some other planet, Natasha will not be able to return home. Fuel is needed to take-off from each planet and to land to each planet. It is known that 1 ton of fuel can lift off a_i tons of rocket from the i-th planet or to land b_i tons of rocket onto the i-th planet.
For example, if the weight of rocket is 9 tons, weight of fuel is 3 tons and take-off coefficient is 8 (a_i = 8), then 1.5 tons of fuel will be burnt (since 1.5 β
8 = 9 + 3). The new weight of fuel after take-off will be 1.5 tons.
Please note, that it is allowed to burn non-integral amount of fuel during take-off or landing, and the amount of initial fuel can be non-integral as well.
Help Natasha to calculate the minimum mass of fuel to load into the rocket. Note, that the rocket must spend fuel to carry both useful cargo and the fuel itself. However, it doesn't need to carry the fuel which has already been burnt. Assume, that the rocket takes off and lands instantly.
Input
The first line contains a single integer n (2 β€ n β€ 1000) β number of planets.
The second line contains the only integer m (1 β€ m β€ 1000) β weight of the payload.
The third line contains n integers a_1, a_2, β¦, a_n (1 β€ a_i β€ 1000), where a_i is the number of tons, which can be lifted off by one ton of fuel.
The fourth line contains n integers b_1, b_2, β¦, b_n (1 β€ b_i β€ 1000), where b_i is the number of tons, which can be landed by one ton of fuel.
It is guaranteed, that if Natasha can make a flight, then it takes no more than 10^9 tons of fuel.
Output
If Natasha can fly to Mars through (n - 2) planets and return to Earth, print the minimum mass of fuel (in tons) that Natasha should take. Otherwise, print a single number -1.
It is guaranteed, that if Natasha can make a flight, then it takes no more than 10^9 tons of fuel.
The answer will be considered correct if its absolute or relative error doesn't exceed 10^{-6}. Formally, let your answer be p, and the jury's answer be q. Your answer is considered correct if \frac{|p - q|}{max{(1, |q|)}} β€ 10^{-6}.
Examples
Input
2
12
11 8
7 5
Output
10.0000000000
Input
3
1
1 4 1
2 5 3
Output
-1
Input
6
2
4 6 3 3 5 6
2 6 3 6 5 3
Output
85.4800000000
Note
Let's consider the first example.
Initially, the mass of a rocket with fuel is 22 tons.
* At take-off from Earth one ton of fuel can lift off 11 tons of cargo, so to lift off 22 tons you need to burn 2 tons of fuel. Remaining weight of the rocket with fuel is 20 tons.
* During landing on Mars, one ton of fuel can land 5 tons of cargo, so for landing 20 tons you will need to burn 4 tons of fuel. There will be 16 tons of the rocket with fuel remaining.
* While taking off from Mars, one ton of fuel can raise 8 tons of cargo, so to lift off 16 tons you will need to burn 2 tons of fuel. There will be 14 tons of rocket with fuel after that.
* During landing on Earth, one ton of fuel can land 7 tons of cargo, so for landing 14 tons you will need to burn 2 tons of fuel. Remaining weight is 12 tons, that is, a rocket without any fuel.
In the second case, the rocket will not be able even to take off from Earth. | import math
def main():
n = int(input())
m = int(input())
a=list(map(int,input().split(" ")))
b=list(map(int,input().split(" ")))
if (1 in a) or (1 in b):
print(-1)
else:
answer = m*math.exp(sum([math.log(1+(1/(x-1))) for x in a+b]))
print(answer-m)
main() | {
"input": [
"2\n12\n11 8\n7 5\n",
"3\n1\n1 4 1\n2 5 3\n",
"6\n2\n4 6 3 3 5 6\n2 6 3 6 5 3\n"
],
"output": [
"10.00000000\n",
"-1.00000000\n",
"85.48000000\n"
]
} |
2,055 | 7 | Mr. F has n positive integers, a_1, a_2, β¦, a_n.
He thinks the greatest common divisor of these integers is too small. So he wants to enlarge it by removing some of the integers.
But this problem is too simple for him, so he does not want to do it by himself. If you help him, he will give you some scores in reward.
Your task is to calculate the minimum number of integers you need to remove so that the greatest common divisor of the remaining integers is bigger than that of all integers.
Input
The first line contains an integer n (2 β€ n β€ 3 β
10^5) β the number of integers Mr. F has.
The second line contains n integers, a_1, a_2, β¦, a_n (1 β€ a_i β€ 1.5 β
10^7).
Output
Print an integer β the minimum number of integers you need to remove so that the greatest common divisor of the remaining integers is bigger than that of all integers.
You should not remove all of the integers.
If there is no solution, print Β«-1Β» (without quotes).
Examples
Input
3
1 2 4
Output
1
Input
4
6 9 15 30
Output
2
Input
3
1 1 1
Output
-1
Note
In the first example, the greatest common divisor is 1 in the beginning. You can remove 1 so that the greatest common divisor is enlarged to 2. The answer is 1.
In the second example, the greatest common divisor is 3 in the beginning. You can remove 6 and 9 so that the greatest common divisor is enlarged to 15. There is no solution which removes only one integer. So the answer is 2.
In the third example, there is no solution to enlarge the greatest common divisor. So the answer is -1. | from math import gcd
n = int(input())
l = list(map(int,input().split()))
m = max(l)+1
prime = [0]*(m)
commondivisor = [0]*(m)
def seive():
for i in range(2,m):
if prime[i] == 0:
for j in range(i*2,m,i):
prime[j] = i
for i in range(2,m):
if not prime[i]:
prime[i] = i
gc = l[0]
for i in range(1,n):
gc = gcd(gc,l[i])
seive()
mi = -1
for i in range(n):
ele = l[i]//gc
while ele > 1:
div = prime[ele]
commondivisor[div]+=1
while ele%div == 0:
ele //= div
mi = max(mi,commondivisor[div])
if mi == -1:
print(-1)
else:
print(n-mi) | {
"input": [
"4\n6 9 15 30\n",
"3\n1 1 1\n",
"3\n1 2 4\n"
],
"output": [
"2\n",
"-1\n",
"1\n"
]
} |
2,056 | 12 | Polycarp, Arkady's friend, prepares to the programming competition and decides to write a contest. The contest consists of n problems and lasts for T minutes. Each of the problems is defined by two positive integers a_i and p_i β its difficulty and the score awarded by its solution.
Polycarp's experience suggests that his skill level is defined with positive real value s, and initially s=1.0. To solve the i-th problem Polycarp needs a_i/s minutes.
Polycarp loves to watch series, and before solving each of the problems he will definitely watch one episode. After Polycarp watches an episode, his skill decreases by 10\%, that is skill level s decreases to 0.9s. Each episode takes exactly 10 minutes to watch. When Polycarp decides to solve some problem, he firstly has to watch one episode, and only then he starts solving the problem without breaks for a_i/s minutes, where s is his current skill level. In calculation of a_i/s no rounding is performed, only division of integer value a_i by real value s happens.
Also, Polycarp can train for some time. If he trains for t minutes, he increases his skill by C β
t, where C is some given positive real constant. Polycarp can train only before solving any problem (and before watching series). Duration of the training can be arbitrary real value.
Polycarp is interested: what is the largest score he can get in the contest? It is allowed to solve problems in any order, while training is only allowed before solving the first problem.
Input
The first line contains one integer tc (1 β€ tc β€ 20) β the number of test cases. Then tc test cases follow.
The first line of each test contains one integer n (1 β€ n β€ 100) β the number of problems in the contest.
The second line of the test contains two real values C, T (0 < C < 10, 0 β€ T β€ 2 β
10^5), where C defines the efficiency of the training and T is the duration of the contest in minutes. Value C, T are given exactly with three digits after the decimal point.
Each of the next n lines of the test contain characteristics of the corresponding problem: two integers a_i, p_i (1 β€ a_i β€ 10^4, 1 β€ p_i β€ 10) β the difficulty and the score of the problem.
It is guaranteed that the value of T is such that changing it by the 0.001 in any direction will not change the test answer.
Please note that in hacks you can only use tc = 1.
Output
Print tc integers β the maximum possible score in each test case.
Examples
Input
2
4
1.000 31.000
12 3
20 6
30 1
5 1
3
1.000 30.000
1 10
10 10
20 8
Output
7
20
Note
In the first example, Polycarp can get score of 7 as follows:
1. Firstly he trains for 4 minutes, increasing s to the value of 5;
2. Then he decides to solve 4-th problem: he watches one episode in 10 minutes, his skill level decreases to s=5*0.9=4.5 and then he solves the problem in 5/s=5/4.5, which is roughly 1.111 minutes;
3. Finally, he decides to solve 2-nd problem: he watches one episode in 10 minutes, his skill level decreases to s=4.5*0.9=4.05 and then he solves the problem in 20/s=20/4.05, which is roughly 4.938 minutes.
This way, Polycarp uses roughly 4+10+1.111+10+4.938=30.049 minutes, to get score of 7 points. It is not possible to achieve larger score in 31 minutes.
In the second example, Polycarp can get 20 points as follows:
1. Firstly he trains for 4 minutes, increasing s to the value of 5;
2. Then he decides to solve 1-st problem: he watches one episode in 10 minutes, his skill decreases to s=5*0.9=4.5 and then he solves problem in 1/s=1/4.5, which is roughly 0.222 minutes.
3. Finally, he decides to solve 2-nd problem: he watches one episode in 10 minutes, his skill decreases to s=4.5*0.9=4.05 and then he solves the problem in 10/s=10/4.05, which is roughly 2.469 minutes.
This way, Polycarp gets score of 20 in 4+10+0.222+10+2.469=26.691 minutes. It is not possible to achieve larger score in 30 minutes. | from math import sqrt
class pro(object):
def __init__(self,dif,sc):
self.dif=dif
self.sc=sc
def __lt__(self,other):
return self.dif>other.dif
T=int(input())
mul=[1]
for i in range(100):
mul.append(mul[i]*10/9)
inf=1000000007
for t in range(T):
n=int(input())
effi,tim=map(float,input().split())
prob=[]
for i in range(n):
x,y=map(int,input().split())
prob.append(pro(x,y))
prob.sort()
f=[[inf for i in range(n+1)] for j in range(1001)]
f[0][0]=0
totsc=0
for i in range(n):
totsc+=prob[i].sc
for j in range(totsc,prob[i].sc-1,-1):
for k in range(1,i+2):
f[j][k]=min(f[j][k],f[j-prob[i].sc][k-1]+prob[i].dif*mul[k])
for i in range(totsc,-1,-1):
flag=False
for j in range(n+1):
if sqrt(effi*f[i][j])>=1:
res=2*sqrt(f[i][j]/effi)-1/effi+10*j
else:
res=f[i][j]+10*j
if res<=tim:
print(i)
flag=True
break
if flag==True:
break
| {
"input": [
"2\n4\n1.000 31.000\n12 3\n20 6\n30 1\n5 1\n3\n1.000 30.000\n1 10\n10 10\n20 8\n"
],
"output": [
"7\n20\n"
]
} |
2,057 | 8 | As a German University in Cairo (GUC) student and a basketball player, Herr Wafa was delighted once he heard the news. GUC is finally participating in the Annual Basketball Competition (ABC).
A team is to be formed of n players, all of which are GUC students. However, the team might have players belonging to different departments. There are m departments in GUC, numbered from 1 to m. Herr Wafa's department has number h. For each department i, Herr Wafa knows number si β how many students who play basketball belong to this department.
Herr Wafa was also able to guarantee a spot on the team, using his special powers. But since he hates floating-point numbers, he needs your help at finding the probability that he will have at least one teammate belonging to his department.
Note that every possible team containing Herr Wafa is equally probable. Consider all the students different from each other.
Input
The first line contains three integers n, m and h (1 β€ n β€ 100, 1 β€ m β€ 1000, 1 β€ h β€ m) β the number of players on the team, the number of departments in GUC and Herr Wafa's department, correspondingly.
The second line contains a single-space-separated list of m integers si (1 β€ si β€ 100), denoting the number of students in the i-th department. Note that sh includes Herr Wafa.
Output
Print the probability that Herr Wafa will have at least one teammate from his department. If there is not enough basketball players in GUC to participate in ABC, print -1. The answer will be accepted if it has absolute or relative error not exceeding 10 - 6.
Examples
Input
3 2 1
2 1
Output
1
Input
3 2 1
1 1
Output
-1
Input
3 2 1
2 2
Output
0.666667
Note
In the first example all 3 players (2 from department 1 and 1 from department 2) must be chosen for the team. Both players from Wafa's departments will be chosen, so he's guaranteed to have a teammate from his department.
In the second example, there are not enough players.
In the third example, there are three possibilities to compose the team containing Herr Wafa. In two of them the other player from Herr Wafa's department is part of the team. |
def nCk(n, k):
res = 1
for i in range(1, k + 1):
res = res * (n - i + 1) // i
return res
n, _, me = map(int, input().split())
a = [0] + list(map(int, input().split()))
s = sum(a)
if n > s:
print(-1)
exit()
allWays = nCk(s - 1, n - 1)
aa=nCk(s-a[me],n-1)
print(1-aa/allWays) | {
"input": [
"3 2 1\n2 1\n",
"3 2 1\n2 2\n",
"3 2 1\n1 1\n"
],
"output": [
"1\n",
"0.6666666666666666666666666667\n",
"-1.0\n"
]
} |
2,058 | 7 | Petya loves lucky numbers. We all know that lucky numbers are the positive integers whose decimal representations contain only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
Petya wonders eagerly what minimum lucky number has the sum of digits equal to n. Help him cope with the task.
Input
The single line contains an integer n (1 β€ n β€ 106) β the sum of digits of the required lucky number.
Output
Print on the single line the result β the minimum lucky number, whose sum of digits equals n. If such number does not exist, print -1.
Examples
Input
11
Output
47
Input
10
Output
-1 | def get_ints():
return list(map(int, input().split()))
N = int(input())
a,b = N//7,N%7
c,d = b//4,b%4
print(-1 if a<d else '4'*(c+2*d) + '7'*(a-d)) | {
"input": [
"10\n",
"11\n"
],
"output": [
"-1\n",
"47\n"
]
} |
2,059 | 7 | At the first holiday in spring, the town Shortriver traditionally conducts a flower festival. Townsfolk wear traditional wreaths during these festivals. Each wreath contains exactly k flowers.
The work material for the wreaths for all n citizens of Shortriver is cut from the longest flowered liana that grew in the town that year. Liana is a sequence a_1, a_2, ..., a_m, where a_i is an integer that denotes the type of flower at the position i. This year the liana is very long (m β₯ n β
k), and that means every citizen will get a wreath.
Very soon the liana will be inserted into a special cutting machine in order to make work material for wreaths. The machine works in a simple manner: it cuts k flowers from the beginning of the liana, then another k flowers and so on. Each such piece of k flowers is called a workpiece. The machine works until there are less than k flowers on the liana.
Diana has found a weaving schematic for the most beautiful wreath imaginable. In order to weave it, k flowers must contain flowers of types b_1, b_2, ..., b_s, while other can be of any type. If a type appears in this sequence several times, there should be at least that many flowers of that type as the number of occurrences of this flower in the sequence. The order of the flowers in a workpiece does not matter.
Diana has a chance to remove some flowers from the liana before it is inserted into the cutting machine. She can remove flowers from any part of the liana without breaking liana into pieces. If Diana removes too many flowers, it may happen so that some of the citizens do not get a wreath. Could some flowers be removed from the liana so that at least one workpiece would conform to the schematic and machine would still be able to create at least n workpieces?
Input
The first line contains four integers m, k, n and s (1 β€ n, k, m β€ 5 β
10^5, k β
n β€ m, 1 β€ s β€ k): the number of flowers on the liana, the number of flowers in one wreath, the amount of citizens and the length of Diana's flower sequence respectively.
The second line contains m integers a_1, a_2, ..., a_m (1 β€ a_i β€ 5 β
10^5) β types of flowers on the liana.
The third line contains s integers b_1, b_2, ..., b_s (1 β€ b_i β€ 5 β
10^5) β the sequence in Diana's schematic.
Output
If it's impossible to remove some of the flowers so that there would be at least n workpieces and at least one of them fullfills Diana's schematic requirements, output -1.
Otherwise in the first line output one integer d β the number of flowers to be removed by Diana.
In the next line output d different integers β the positions of the flowers to be removed.
If there are multiple answers, print any.
Examples
Input
7 3 2 2
1 2 3 3 2 1 2
2 2
Output
1
4
Input
13 4 3 3
3 2 6 4 1 4 4 7 1 3 3 2 4
4 3 4
Output
-1
Input
13 4 1 3
3 2 6 4 1 4 4 7 1 3 3 2 4
4 3 4
Output
9
1 2 3 4 5 9 11 12 13
Note
In the first example, if you don't remove any flowers, the machine would put out two workpieces with flower types [1, 2, 3] and [3, 2, 1]. Those workpieces don't fit Diana's schematic. But if you remove flower on 4-th place, the machine would output workpieces [1, 2, 3] and [2, 1, 2]. The second workpiece fits Diana's schematic.
In the second example there is no way to remove flowers so that every citizen gets a wreath and Diana gets a workpiece that fits here schematic.
In the third example Diana is the only citizen of the town and that means she can, for example, just remove all flowers except the ones she needs. | from sys import stdin, stdout, setrecursionlimit
input = stdin.readline
# import string
# characters = string.ascii_lowercase
# digits = string.digits
# setrecursionlimit(int(1e6))
# dir = [-1,0,1,0,-1]
# moves = 'NESW'
inf = float('inf')
from functools import cmp_to_key
from collections import defaultdict as dd
from collections import Counter, deque
from heapq import *
import math
from math import floor, ceil, sqrt
def geti(): return map(int, input().strip().split())
def getl(): return list(map(int, input().strip().split()))
def getis(): return map(str, input().strip().split())
def getls(): return list(map(str, input().strip().split()))
def gets(): return input().strip()
def geta(): return int(input())
def print_s(s): stdout.write(s+'\n')
def solve():
m, k, n, s = geti()
a = getl()
s = Counter(getl())
length = k + m - n * k
val = sum(s.values())
occur = dd(int)
ok = 0
i = 0
done = 0
start = 0
# print(length)
while i < m:
while done != length and i < m:
occur[a[i]] += 1
if occur[a[i]] == s[a[i]]:
ok += 1
done += 1
i += 1
# print(done, start, ok)
if ok == len(s):
res = []
need = length - k
for j in range(start, start + length):
if not need:
break
if occur[a[j]] > s[a[j]]:
occur[a[j]] -= 1
res.append(j+1)
need -= 1
print(len(res))
print(*res)
break
else:
waste = k
while waste:
if occur[a[start]] == s[a[start]]:
ok -= 1
occur[a[start]] -= 1
waste -= 1
start += 1
done -= 1
else:
print(-1)
# def check(length):
# occur = dd(int)
# ok = 0
# prev = 0
# start = m-1
# for i in range(m):
# if a[i] in s:
# start = i
# break
# prev += 1
# prev %= k
# for i in range(start, m):
# occur[a[i]] += 1
# if occur[a[i]] == s[a[i]]:
# ok += 1
# if ok == len(s):
# # print(start, prev, i)
# total = i - start + 1
# to_rem = total - k + prev
# if to_rem <= 0:
# return []
# if to_rem <= length:
# res = []
# for j in range(start-1, -1, -1):
# if prev:
# res.append(j + 1)
# prev -= 1
# to_rem -= 1
# else:
# break
# for j in range(start, i):
# if occur[a[j]] > s[a[j]]:
# res.append(j + 1)
# to_rem -= 1
# if not to_rem:
# break
# return res
# else:
# while start < i:
# occur[a[start]] -= 1
# prev += 1
# prev %= k
# start += 1
# if a[start-1] in s and occur[a[start-1]] < s[a[start-1]]:
# ok -= 1
# if a[start] in s:
# break
# # print(a[start:])
# # print(Counter(a[start:]))
# # print(s)
# return -1
#
# res = check(length)
# if res == -1:
# print(res)
# else:
# print(len(res))
# if res:
# print(*res)
if __name__=='__main__':
solve()
| {
"input": [
"7 3 2 2\n1 2 3 3 2 1 2\n2 2\n",
"13 4 1 3\n3 2 6 4 1 4 4 7 1 3 3 2 4\n4 3 4\n",
"13 4 3 3\n3 2 6 4 1 4 4 7 1 3 3 2 4\n4 3 4\n"
],
"output": [
"1\n4\n",
"2\n2\n3\n",
"-1\n"
]
} |
2,060 | 9 | Alice and Bob are playing a game with n piles of stones. It is guaranteed that n is an even number. The i-th pile has a_i stones.
Alice and Bob will play a game alternating turns with Alice going first.
On a player's turn, they must choose exactly n/2 nonempty piles and independently remove a positive number of stones from each of the chosen piles. They can remove a different number of stones from the piles in a single turn. The first player unable to make a move loses (when there are less than n/2 nonempty piles).
Given the starting configuration, determine who will win the game.
Input
The first line contains one integer n (2 β€ n β€ 50) β the number of piles. It is guaranteed that n is an even number.
The second line contains n integers a_1, a_2, β¦, a_n (1 β€ a_i β€ 50) β the number of stones in the piles.
Output
Print a single string "Alice" if Alice wins; otherwise, print "Bob" (without double quotes).
Examples
Input
2
8 8
Output
Bob
Input
4
3 1 4 1
Output
Alice
Note
In the first example, each player can only remove stones from one pile (2/2=1). Alice loses, since Bob can copy whatever Alice does on the other pile, so Alice will run out of moves first.
In the second example, Alice can remove 2 stones from the first pile and 3 stones from the third pile on her first move to guarantee a win. | def judge(i):
return "Bob" if cnt[i]>n//2 else "Alice"
n=int(input())
a=list(map(int,input().split()))
cnt=[0 for i in range(51)]
for i in a:
cnt[i]+=1
print(judge(min(a))) | {
"input": [
"4\n3 1 4 1\n",
"2\n8 8\n"
],
"output": [
"Alice\n",
"Bob\n"
]
} |
2,061 | 7 | Your favorite shop sells n Kinder Surprise chocolate eggs. You know that exactly s stickers and exactly t toys are placed in n eggs in total.
Each Kinder Surprise can be one of three types:
* it can contain a single sticker and no toy;
* it can contain a single toy and no sticker;
* it can contain both a single sticker and a single toy.
But you don't know which type a particular Kinder Surprise has. All eggs look identical and indistinguishable from each other.
What is the minimum number of Kinder Surprise Eggs you have to buy to be sure that, whichever types they are, you'll obtain at least one sticker and at least one toy?
Note that you do not open the eggs in the purchasing process, that is, you just buy some number of eggs. It's guaranteed that the answer always exists.
Input
The first line contains the single integer T (1 β€ T β€ 100) β the number of queries.
Next T lines contain three integers n, s and t each (1 β€ n β€ 10^9, 1 β€ s, t β€ n, s + t β₯ n) β the number of eggs, stickers and toys.
All queries are independent.
Output
Print T integers (one number per query) β the minimum number of Kinder Surprise Eggs you have to buy to be sure that, whichever types they are, you'll obtain at least one sticker and one toy
Example
Input
3
10 5 7
10 10 10
2 1 1
Output
6
1
2
Note
In the first query, we have to take at least 6 eggs because there are 5 eggs with only toy inside and, in the worst case, we'll buy all of them.
In the second query, all eggs have both a sticker and a toy inside, that's why it's enough to buy only one egg.
In the third query, we have to buy both eggs: one with a sticker and one with a toy. | def foo():
n, s, t = map(int, input().split())
print(max(n-s, n-t)+1)
for _ in range(int(input())):
foo() | {
"input": [
"3\n10 5 7\n10 10 10\n2 1 1\n"
],
"output": [
"6\n1\n2\n"
]
} |
2,062 | 9 | You are an environmental activist at heart but the reality is harsh and you are just a cashier in a cinema. But you can still do something!
You have n tickets to sell. The price of the i-th ticket is p_i. As a teller, you have a possibility to select the order in which the tickets will be sold (i.e. a permutation of the tickets). You know that the cinema participates in two ecological restoration programs applying them to the order you chose:
* The x\% of the price of each the a-th sold ticket (a-th, 2a-th, 3a-th and so on) in the order you chose is aimed for research and spreading of renewable energy sources.
* The y\% of the price of each the b-th sold ticket (b-th, 2b-th, 3b-th and so on) in the order you chose is aimed for pollution abatement.
If the ticket is in both programs then the (x + y) \% are used for environmental activities. Also, it's known that all prices are multiples of 100, so there is no need in any rounding.
For example, if you'd like to sell tickets with prices [400, 100, 300, 200] and the cinema pays 10\% of each 2-nd sold ticket and 20\% of each 3-rd sold ticket, then arranging them in order [100, 200, 300, 400] will lead to contribution equal to 100 β
0 + 200 β
0.1 + 300 β
0.2 + 400 β
0.1 = 120. But arranging them in order [100, 300, 400, 200] will lead to 100 β
0 + 300 β
0.1 + 400 β
0.2 + 200 β
0.1 = 130.
Nature can't wait, so you decided to change the order of tickets in such a way, so that the total contribution to programs will reach at least k in minimum number of sold tickets. Or say that it's impossible to do so. In other words, find the minimum number of tickets which are needed to be sold in order to earn at least k.
Input
The first line contains a single integer q (1 β€ q β€ 100) β the number of independent queries. Each query consists of 5 lines.
The first line of each query contains a single integer n (1 β€ n β€ 2 β
10^5) β the number of tickets.
The second line contains n integers p_1, p_2, ..., p_n (100 β€ p_i β€ 10^9, p_i mod 100 = 0) β the corresponding prices of tickets.
The third line contains two integers x and a (1 β€ x β€ 100, x + y β€ 100, 1 β€ a β€ n) β the parameters of the first program.
The fourth line contains two integers y and b (1 β€ y β€ 100, x + y β€ 100, 1 β€ b β€ n) β the parameters of the second program.
The fifth line contains single integer k (1 β€ k β€ 10^{14}) β the required total contribution.
It's guaranteed that the total number of tickets per test doesn't exceed 2 β
10^5.
Output
Print q integers β one per query.
For each query, print the minimum number of tickets you need to sell to make the total ecological contribution of at least k if you can sell tickets in any order.
If the total contribution can not be achieved selling all the tickets, print -1.
Example
Input
4
1
100
50 1
49 1
100
8
100 200 100 200 100 200 100 100
10 2
15 3
107
3
1000000000 1000000000 1000000000
50 1
50 1
3000000000
5
200 100 100 100 100
69 5
31 2
90
Output
-1
6
3
4
Note
In the first query the total contribution is equal to 50 + 49 = 99 < 100, so it's impossible to gather enough money.
In the second query you can rearrange tickets in a following way: [100, 100, 200, 200, 100, 200, 100, 100] and the total contribution from the first 6 tickets is equal to 100 β
0 + 100 β
0.1 + 200 β
0.15 + 200 β
0.1 + 100 β
0 + 200 β
0.25 = 10 + 30 + 20 + 50 = 110.
In the third query the full price of each ticket goes to the environmental activities.
In the fourth query you can rearrange tickets as [100, 200, 100, 100, 100] and the total contribution from the first 4 tickets is 100 β
0 + 200 β
0.31 + 100 β
0 + 100 β
0.31 = 62 + 31 = 93. | def cout(n):
cxy, cx, cy, s = 0, 0, 0, 0
for i in range(1, n + 1):
if not i % a:
if not i % b: cxy += 1
else: cx += 1
elif not i % b: cy += 1
#print(n,cxy,cx,cy,p)
return (sum(p[:cxy])*(x+y)+sum(p[cxy:cxy+cx])*x+sum(p[cxy+cx:cxy+cx+cy])*y)//100
for q in range(int(input())):
n = int(input())
p = sorted(list(map(int, input().split())), reverse=True)
x, a = map(int, input().split())
y, b = map(int, input().split())
k = int(input())
if y > x: x, a, y, b = y, b, x, a
if cout(n) < k: print(-1)
else:
low, high = 1, n
while low < high:
mid = (low + high) // 2
#print(cout(mid),mid)
if cout(mid) >= k: high = mid
else: low = mid + 1
print(low)
| {
"input": [
"4\n1\n100\n50 1\n49 1\n100\n8\n100 200 100 200 100 200 100 100\n10 2\n15 3\n107\n3\n1000000000 1000000000 1000000000\n50 1\n50 1\n3000000000\n5\n200 100 100 100 100\n69 5\n31 2\n90\n"
],
"output": [
"-1\n6\n3\n4\n"
]
} |
2,063 | 11 | Byteburg Senate elections are coming. Usually "United Byteland", the ruling Byteland party, takes all the seats in the Senate to ensure stability and sustainable development. But this year there is one opposition candidate in one of the constituencies. Even one opposition member can disturb the stability in the Senate, so the head of the Party asks you to ensure that the opposition candidate will not be elected.
There are n candidates, numbered from 1 to n. Candidate n is the opposition candidate. There are m polling stations in the constituency, numbered from 1 to m. You know the number of votes cast for each candidate at each polling station. The only thing you can do to prevent the election of the opposition candidate is to cancel the election results at some polling stations. The opposition candidate will be elected if the sum of the votes cast in their favor at all non-canceled stations will be strictly greater than the analogous sum for every other candidate.
Your task is to prevent the election of the opposition candidate by canceling the election results at the minimal possible number of polling stations. Notice that solution always exists, because if you cancel the elections at all polling stations, the number of votes for each candidate will be 0, and the opposition candidate will not be elected.
Input
The first line of the input contains two integers n and m (2β€ nβ€ 100; 1β€ m β€ 100) β the number of candidates and the number of polling stations. The next m lines contain the election results at each polling station with n numbers on each line. In the i-th line the j-th number is a_{i,j} β the number of votes cast for the candidate j at the station i (0β€ a_{i,j} β€ 1 000).
Output
In the first line output integer k β the minimal number of the polling stations in which you need to cancel the election results. In the second line output k integers β the indices of canceled polling stations, in any order. If there are multiple ways to cancel results at k stations, output any one of them.
Examples
Input
5 3
6 3 4 2 8
3 7 5 6 7
5 2 4 7 9
Output
2
3 1
Input
2 1
1 1
Output
0
Input
3 3
2 3 8
4 2 9
3 1 7
Output
3
1 2 3
Note
In the first example, the candidates from 1 to 5 received 14, 12, 13, 15, and 24 votes correspondingly. The opposition candidate has the most votes. However, if you cancel the election results at the first and the third polling stations, then only the result from the second polling station remains and the vote sums become 3, 7, 5, 6, and 7, without the opposition candidate being in the lead anymore. | n,m=map(int,input().split())
a = [list(map(int,input().split())) for _ in range(m)]
def calc(idx):
diff = sorted([(x[-1] - x[idx], i) for i, x in enumerate(a)])
tot = sum([x[0] for x in diff])
ans = []
while tot > 0:
tot -= diff[-1][0]
ans.append(diff[-1][1]+1)
diff.pop()
return ans
ans = [i+1 for i in range(m)]
for i in range(n-1):
temp = calc(i)
if len(temp) < len(ans):
ans = temp
print(len(ans))
print(" ".join(map(str,ans)))
| {
"input": [
"2 1\n1 1\n",
"3 3\n2 3 8\n4 2 9\n3 1 7\n",
"5 3\n6 3 4 2 8\n3 7 5 6 7\n5 2 4 7 9\n"
],
"output": [
"0\n",
"3\n1 2 3",
"2\n3 1"
]
} |
2,064 | 7 | Alice has a cute cat. To keep her cat fit, Alice wants to design an exercising walk for her cat!
Initially, Alice's cat is located in a cell (x,y) of an infinite grid. According to Alice's theory, cat needs to move:
* exactly a steps left: from (u,v) to (u-1,v);
* exactly b steps right: from (u,v) to (u+1,v);
* exactly c steps down: from (u,v) to (u,v-1);
* exactly d steps up: from (u,v) to (u,v+1).
Note that the moves can be performed in an arbitrary order. For example, if the cat has to move 1 step left, 3 steps right and 2 steps down, then the walk right, down, left, right, right, down is valid.
Alice, however, is worrying that her cat might get lost if it moves far away from her. So she hopes that her cat is always in the area [x_1,x_2]Γ [y_1,y_2], i.e. for every cat's position (u,v) of a walk x_1 β€ u β€ x_2 and y_1 β€ v β€ y_2 holds.
Also, note that the cat can visit the same cell multiple times.
Can you help Alice find out if there exists a walk satisfying her wishes?
Formally, the walk should contain exactly a+b+c+d unit moves (a to the left, b to the right, c to the down, d to the up). Alice can do the moves in any order. Her current position (u, v) should always satisfy the constraints: x_1 β€ u β€ x_2, y_1 β€ v β€ y_2. The staring point is (x, y).
You are required to answer t test cases independently.
Input
The first line contains a single integer t (1 β€ t β€ 10^3) β the number of testcases.
The first line of each test case contains four integers a, b, c, d (0 β€ a,b,c,d β€ 10^8, a+b+c+d β₯ 1).
The second line of the test case contains six integers x, y, x_1, y_1, x_2, y_2 (-10^8 β€ x_1β€ x β€ x_2 β€ 10^8, -10^8 β€ y_1 β€ y β€ y_2 β€ 10^8).
Output
For each test case, output "YES" in a separate line, if there exists a walk satisfying her wishes. Otherwise, output "NO" in a separate line.
You can print each letter in any case (upper or lower).
Example
Input
6
3 2 2 2
0 0 -2 -2 2 2
3 1 4 1
0 0 -1 -1 1 1
1 1 1 1
1 1 1 1 1 1
0 0 0 1
0 0 0 0 0 1
5 1 1 1
0 0 -100 -100 0 100
1 1 5 1
0 0 -100 -100 100 0
Output
Yes
No
No
Yes
Yes
Yes
Note
In the first test case, one valid exercising walk is $$$(0,0)β (-1,0) β (-2,0)β (-2,1) β (-2,2)β (-1,2)β(0,2)β (0,1)β (0,0) β (-1,0)$$$ | def check(a, b, s, l, r):
if a + b == 0: return 1
if l == r: return 0
if l <= s - a + b <= r: return 1
return 0
T = int(input())
for _ in range(T):
a, b, c, d = map(int, input().split())
x, y, x1, y1, x2, y2 = map(int, input().split())
print("YES" if check(a, b, x, x1, x2) and check(c, d, y, y1, y2) else "NO")
| {
"input": [
"6\n3 2 2 2\n0 0 -2 -2 2 2\n3 1 4 1\n0 0 -1 -1 1 1\n1 1 1 1\n1 1 1 1 1 1\n0 0 0 1\n0 0 0 0 0 1\n5 1 1 1\n0 0 -100 -100 0 100\n1 1 5 1\n0 0 -100 -100 100 0\n"
],
"output": [
"Yes\nNo\nNo\nYes\nYes\nYes\n"
]
} |
2,065 | 10 | There are n candies in a row, they are numbered from left to right from 1 to n. The size of the i-th candy is a_i.
Alice and Bob play an interesting and tasty game: they eat candy. Alice will eat candy from left to right, and Bob β from right to left. The game ends if all the candies are eaten.
The process consists of moves. During a move, the player eats one or more sweets from her/his side (Alice eats from the left, Bob β from the right).
Alice makes the first move. During the first move, she will eat 1 candy (its size is a_1). Then, each successive move the players alternate β that is, Bob makes the second move, then Alice, then again Bob and so on.
On each move, a player counts the total size of candies eaten during the current move. Once this number becomes strictly greater than the total size of candies eaten by the other player on their previous move, the current player stops eating and the move ends. In other words, on a move, a player eats the smallest possible number of candies such that the sum of the sizes of candies eaten on this move is strictly greater than the sum of the sizes of candies that the other player ate on the previous move. If there are not enough candies to make a move this way, then the player eats up all the remaining candies and the game ends.
For example, if n=11 and a=[3,1,4,1,5,9,2,6,5,3,5], then:
* move 1: Alice eats one candy of size 3 and the sequence of candies becomes [1,4,1,5,9,2,6,5,3,5].
* move 2: Alice ate 3 on the previous move, which means Bob must eat 4 or more. Bob eats one candy of size 5 and the sequence of candies becomes [1,4,1,5,9,2,6,5,3].
* move 3: Bob ate 5 on the previous move, which means Alice must eat 6 or more. Alice eats three candies with the total size of 1+4+1=6 and the sequence of candies becomes [5,9,2,6,5,3].
* move 4: Alice ate 6 on the previous move, which means Bob must eat 7 or more. Bob eats two candies with the total size of 3+5=8 and the sequence of candies becomes [5,9,2,6].
* move 5: Bob ate 8 on the previous move, which means Alice must eat 9 or more. Alice eats two candies with the total size of 5+9=14 and the sequence of candies becomes [2,6].
* move 6 (the last): Alice ate 14 on the previous move, which means Bob must eat 15 or more. It is impossible, so Bob eats the two remaining candies and the game ends.
Print the number of moves in the game and two numbers:
* a β the total size of all sweets eaten by Alice during the game;
* b β the total size of all sweets eaten by Bob during the game.
Input
The first line contains an integer t (1 β€ t β€ 5000) β the number of test cases in the input. The following are descriptions of the t test cases.
Each test case consists of two lines. The first line contains an integer n (1 β€ n β€ 1000) β the number of candies. The second line contains a sequence of integers a_1, a_2, ..., a_n (1 β€ a_i β€ 1000) β the sizes of candies in the order they are arranged from left to right.
It is guaranteed that the sum of the values of n for all sets of input data in a test does not exceed 2β
10^5.
Output
For each set of input data print three integers β the number of moves in the game and the required values a and b.
Example
Input
7
11
3 1 4 1 5 9 2 6 5 3 5
1
1000
3
1 1 1
13
1 2 3 4 5 6 7 8 9 10 11 12 13
2
2 1
6
1 1 1 1 1 1
7
1 1 1 1 1 1 1
Output
6 23 21
1 1000 0
2 1 2
6 45 46
2 2 1
3 4 2
4 4 3 | import collections
t = int(input())
def solve(n, arr):
arr = collections.deque(arr)
a = 0
b = 0
turns = 0
turn = 0
last = 0
while len(arr) > 0:
#print(arr)
turns += 1
ate = 0
while ate <= last and len(arr) > 0:
if turn == 0:
ate += arr.popleft()
else:
ate += arr.pop()
last = ate
if turn == 0:
a += ate
else:
b += ate
turn ^= 1
print(turns, a, b)
for _ in range(t):
n = int(input())
arr = list(map(int, input().split()))
solve(n, arr) | {
"input": [
"7\n11\n3 1 4 1 5 9 2 6 5 3 5\n1\n1000\n3\n1 1 1\n13\n1 2 3 4 5 6 7 8 9 10 11 12 13\n2\n2 1\n6\n1 1 1 1 1 1\n7\n1 1 1 1 1 1 1\n"
],
"output": [
"6 23 21\n1 1000 0\n2 1 2\n6 45 46\n2 2 1\n3 4 2\n4 4 3\n"
]
} |
2,066 | 8 | In Omkar's last class of math, he learned about the least common multiple, or LCM. LCM(a, b) is the smallest positive integer x which is divisible by both a and b.
Omkar, having a laudably curious mind, immediately thought of a problem involving the LCM operation: given an integer n, find positive integers a and b such that a + b = n and LCM(a, b) is the minimum value possible.
Can you help Omkar solve his ludicrously challenging math problem?
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 β€ t β€ 10). Description of the test cases follows.
Each test case consists of a single integer n (2 β€ n β€ 10^{9}).
Output
For each test case, output two positive integers a and b, such that a + b = n and LCM(a, b) is the minimum possible.
Example
Input
3
4
6
9
Output
2 2
3 3
3 6
Note
For the first test case, the numbers we can choose are 1, 3 or 2, 2. LCM(1, 3) = 3 and LCM(2, 2) = 2, so we output 2 \ 2.
For the second test case, the numbers we can choose are 1, 5, 2, 4, or 3, 3. LCM(1, 5) = 5, LCM(2, 4) = 4, and LCM(3, 3) = 3, so we output 3 \ 3.
For the third test case, LCM(3, 6) = 6. It can be shown that there are no other pairs of numbers which sum to 9 that have a lower LCM. | def compute(N):
if N%2==0:
return(N//2,N//2)
else:
for i in range(2,int(N**0.5)+1):
if N%i==0:
return (N//i,N-N//i)
return (N-1,1)
for i in range(int(input())):
N=int(input())
print(*compute(N)) | {
"input": [
"3\n4\n6\n9\n"
],
"output": [
"2 2\n3 3\n3 6\n"
]
} |
2,067 | 7 | Boboniu gives you
* r red balls,
* g green balls,
* b blue balls,
* w white balls.
He allows you to do the following operation as many times as you want:
* Pick a red ball, a green ball, and a blue ball and then change their color to white.
You should answer if it's possible to arrange all the balls into a palindrome after several (possibly zero) number of described operations.
Input
The first line contains one integer T (1β€ Tβ€ 100) denoting the number of test cases.
For each of the next T cases, the first line contains four integers r, g, b and w (0β€ r,g,b,wβ€ 10^9).
Output
For each test case, print "Yes" if it's possible to arrange all the balls into a palindrome after doing several (possibly zero) number of described operations. Otherwise, print "No".
Example
Input
4
0 1 1 1
8 1 9 3
0 0 0 0
1000000000 1000000000 1000000000 1000000000
Output
No
Yes
Yes
Yes
Note
In the first test case, you're not able to do any operation and you can never arrange three balls of distinct colors into a palindrome.
In the second test case, after doing one operation, changing (8,1,9,3) to (7,0,8,6), one of those possible palindromes may be "rrrwwwbbbbrbbbbwwwrrr".
A palindrome is a word, phrase, or sequence that reads the same backwards as forwards. For example, "rggbwbggr", "b", "gg" are palindromes while "rgbb", "gbbgr" are not. Notice that an empty word, phrase, or sequence is palindrome. | def f(l):
fixed = 0 in l[:3] #can odd/even be flipped?
return sum([i%2 for i in l])<2 if fixed else sum([i%2 for i in l])!=2
q = int(input())
[print('Yes' if f(list(map(int,input().split()))) else 'No') for _ in range(q)]
| {
"input": [
"4\n0 1 1 1\n8 1 9 3\n0 0 0 0\n1000000000 1000000000 1000000000 1000000000\n"
],
"output": [
"No\nYes\nYes\nYes\n"
]
} |
2,068 | 10 | This is the easy version of the problem. The difference between the versions is that in the easy version all prices a_i are different. You can make hacks if and only if you solved both versions of the problem.
Today is Sage's birthday, and she will go shopping to buy ice spheres. All n ice spheres are placed in a row and they are numbered from 1 to n from left to right. Each ice sphere has a positive integer price. In this version all prices are different.
An ice sphere is cheap if it costs strictly less than two neighboring ice spheres: the nearest to the left and the nearest to the right. The leftmost and the rightmost ice spheres are not cheap. Sage will choose all cheap ice spheres and then buy only them.
You can visit the shop before Sage and reorder the ice spheres as you wish. Find out the maximum number of ice spheres that Sage can buy, and show how the ice spheres should be reordered.
Input
The first line contains a single integer n (1 β€ n β€ 10^5) β the number of ice spheres in the shop.
The second line contains n different integers a_1, a_2, ..., a_n (1 β€ a_i β€ 10^9) β the prices of ice spheres.
Output
In the first line print the maximum number of ice spheres that Sage can buy.
In the second line print the prices of ice spheres in the optimal order. If there are several correct answers, you can print any of them.
Example
Input
5
1 2 3 4 5
Output
2
3 1 4 2 5
Note
In the example it's not possible to place ice spheres in any order so that Sage would buy 3 of them. If the ice spheres are placed like this (3, 1, 4, 2, 5), then Sage will buy two spheres: one for 1 and one for 2, because they are cheap. | def swap(x,i):
x[i],x[i+1]=x[i+1],x[i]
return x
n=int(input())
x=list(map(int,input().split()))
x=sorted(x)
ans=n/2
if ans.is_integer():
print(int(ans-1))
else:
print(int(ans))
for i in range(0,n-2,2):
swap(x,i)
print(*x)
| {
"input": [
"5\n1 2 3 4 5\n"
],
"output": [
"2\n3 1 4 2 5\n"
]
} |
2,069 | 10 | Monocarp had a tree which consisted of n vertices and was rooted at vertex 1. He decided to study BFS ([Breadth-first search](https://en.wikipedia.org/wiki/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 β€ t β€ 1000) β the number of test cases.
The first line of each test case contains a single integer n (2 β€ n β€ 2 β
10^5) β the number of vertices in the tree.
The second line of each test case contains n integers a_1, a_2, ..., a_n (1 β€ a_i β€ n; a_i β 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 β
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> | def tree(arr):
count=0
base=[0]*(len(arr)+1)
for i in range(1,len(arr)):
if i-1>0 and arr[i]<arr[i-1]:
count+=1
base[i]=base[count]+1
return base[len(arr)-1]
t=int(input())
for i in range(t):
n=input()
print(tree(list(map(int,input().strip().split())))) | {
"input": [
"3\n4\n1 4 3 2\n2\n1 2\n3\n1 2 3\n"
],
"output": [
"3\n1\n1\n"
]
} |
2,070 | 8 | Polycarp has a string s[1 ... n] of length n consisting of decimal digits. Polycarp performs the following operation with the string s no more than once (i.e. he can perform operation 0 or 1 time):
* Polycarp selects two numbers i and j (1 β€ i β€ j β€ n) and removes characters from the s string at the positions i, i+1, i+2, β¦, j (i.e. removes substring s[i ... j]). More formally, Polycarp turns the string s into the string s_1 s_2 β¦ s_{i-1} s_{j+1} s_{j+2} β¦ s_{n}.
For example, the string s = "20192020" Polycarp can turn into strings:
* "2020" (in this case (i, j)=(3, 6) or (i, j)=(1, 4));
* "2019220" (in this case (i, j)=(6, 6));
* "020" (in this case (i, j)=(1, 5));
* other operations are also possible, only a few of them are listed above.
Polycarp likes the string "2020" very much, so he is wondering if it is possible to turn the string s into a string "2020" in no more than one operation? Note that you can perform zero operations.
Input
The first line contains a positive integer t (1 β€ t β€ 1000 ) β number of test cases in the test. Then t test cases follow.
The first line of each test case contains an integer n (4 β€ n β€ 200) β length of the string s. The next line contains a string s of length n consisting of decimal digits. It is allowed that the string s starts with digit 0.
Output
For each test case, output on a separate line:
* "YES" if Polycarp can turn the string s into a string "2020" in no more than one operation (i.e. he can perform 0 or 1 operation);
* "NO" otherwise.
You may print every letter of "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
8
20192020
8
22019020
4
2020
5
20002
6
729040
6
200200
Output
YES
YES
YES
NO
NO
NO
Note
In the first test case, Polycarp could choose i=3 and j=6.
In the second test case, Polycarp could choose i=2 and j=5.
In the third test case, Polycarp did not perform any operations with the string. | cases = int(input())
def solve(s):
arr = [s[:4], s[-4:], s[:1] + s[-3:], s[:2] + s[-2:], s[:3] + s[-1:]]
# print(arr)
return 'YES' if '2020' in arr else 'NO'
for _ in range(cases):
n = int(input())
print(solve(input()))
| {
"input": [
"6\n8\n20192020\n8\n22019020\n4\n2020\n5\n20002\n6\n729040\n6\n200200\n"
],
"output": [
"\nYES\nYES\nYES\nNO\nNO\nNO\n"
]
} |
2,071 | 9 | A big football championship will occur soon! n teams will compete in it, and each pair of teams will play exactly one game against each other.
There are two possible outcomes of a game:
* the game may result in a tie, then both teams get 1 point;
* one team might win in a game, then the winning team gets 3 points and the losing team gets 0 points.
The score of a team is the number of points it gained during all games that it played.
You are interested in a hypothetical situation when all teams get the same score at the end of the championship. A simple example of that situation is when all games result in ties, but you want to minimize the number of ties as well.
Your task is to describe a situation (choose the result of each game) so that all teams get the same score, and the number of ties is the minimum possible.
Input
The first line contains one integer t (1 β€ t β€ 100) β the number of test cases.
Then the test cases follow. Each test case is described by one line containing one integer n (2 β€ n β€ 100) β the number of teams.
Output
For each test case, print (n(n - 1))/(2) integers describing the results of the games in the following order: the first integer should correspond to the match between team 1 and team 2, the second β between team 1 and team 3, then 1 and 4, ..., 1 and n, 2 and 3, 2 and 4, ..., 2 and n, and so on, until the game between the team n - 1 and the team n.
The integer corresponding to the game between the team x and the team y should be 1 if x wins, -1 if y wins, or 0 if the game results in a tie.
All teams should get the same score, and the number of ties should be the minimum possible. If there are multiple optimal answers, print any of them. It can be shown that there always exists a way to make all teams have the same score.
Example
Input
2
2
3
Output
0
1 -1 1
Note
In the first test case of the example, both teams get 1 point since the game between them is a tie.
In the second test case of the example, team 1 defeats team 2 (team 1 gets 3 points), team 1 loses to team 3 (team 3 gets 3 points), and team 2 wins against team 3 (team 2 gets 3 points). | def main():
for _ in range(int(input())):
n = int(input())
odd = n % 2
le, res = (n - 2 + odd) // 2, []
ptrn = ['1'] * le
if not odd:
ptrn.append('0')
ptrn += ['-1'] * le
for _ in range(n - 1):
res += ptrn
del ptrn[-1]
print(' '.join(res))
if __name__ == '__main__':
main()
| {
"input": [
"2\n2\n3\n"
],
"output": [
"\n0 \n1 -1 1 \n"
]
} |
2,072 | 11 | Polycarp came up with a new programming language. There are only two types of statements in it:
* "x := s": assign the variable named x the value s (where s is a string). For example, the statement var := hello assigns the variable named var the value hello. Note that s is the value of a string, not the name of a variable. Between the variable name, the := operator and the string contains exactly one space each.
* "x = a + b": assign the variable named x the concatenation of values of two variables a and b. For example, if the program consists of three statements a := hello, b := world, c = a + b, then the variable c will contain the string helloworld. It is guaranteed that the program is correct and the variables a and b were previously defined. There is exactly one space between the variable names and the = and + operators.
All variable names and strings only consist of lowercase letters of the English alphabet and do not exceed 5 characters.
The result of the program is the number of occurrences of string haha in the string that was written to the variable in the last statement.
Polycarp was very tired while inventing that language. He asks you to implement it. Your task is β for given program statements calculate the number of occurrences of string haha in the last assigned variable.
Input
The first line contains an integer t (1 β€ t β€ 10^3). Then t test cases follow.
The first line of each test case contains a single integer n (1 β€ n β€ 50) β the number of statements in the program. All variable names and strings are guaranteed to consist only of lowercase letters of the English alphabet and do not exceed 5 characters.
This is followed by n lines describing the statements in the format described above. It is guaranteed that the program is correct.
Output
For each set of input data, output the number of occurrences of the haha substring in the string that was written to the variable in the last statement.
Example
Input
4
6
a := h
b := aha
c = a + b
c = c + c
e = c + c
d = a + c
15
x := haha
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
1
haha := hah
5
haahh := aaaha
ahhhh = haahh + haahh
haahh = haahh + haahh
ahhhh = ahhhh + haahh
ahhaa = haahh + ahhhh
Output
3
32767
0
0
Note
In the first test case the resulting value of d is hhahahaha. | import re
def merge(x,y):
c=len(re.findall('(?=haha)',x[1]+y[0]))
return(x[0]+y[0])[:3],(x[1]+y[1])[-3:],x[2]+y[2]+c
i=input
for _ in[1]*int(i()):
mp={}
for _ in[1]*int(i()):
s=i()
if ':='in s:
k,_,v =s.split()
mp[k]=(v[:3],v[-3:],v.count('haha'))
else:
k,_,x,_,y=s.split()
mp[k]=merge(mp[x],mp[y])
print(mp[k][2])
| {
"input": [
"4\n6\na := h\nb := aha\nc = a + b\nc = c + c\ne = c + c\nd = a + c\n15\nx := haha\nx = x + x\nx = x + x\nx = x + x\nx = x + x\nx = x + x\nx = x + x\nx = x + x\nx = x + x\nx = x + x\nx = x + x\nx = x + x\nx = x + x\nx = x + x\nx = x + x\n1\nhaha := hah\n5\nhaahh := aaaha\nahhhh = haahh + haahh\nhaahh = haahh + haahh\nahhhh = ahhhh + haahh\nahhaa = haahh + ahhhh\n"
],
"output": [
"\n3\n32767\n0\n0\n"
]
} |
2,073 | 7 | Some dwarves that are finishing the StUDY (State University for Dwarven Youngsters) Bachelor courses, have been told "no genome, no degree". That means that all dwarves should write a thesis on genome. Dwarven genome is far from simple. It is represented by a string that consists of lowercase Latin letters.
Dwarf Misha has already chosen the subject for his thesis: determining by two dwarven genomes, whether they belong to the same race. Two dwarves belong to the same race if we can swap two characters in the first dwarf's genome and get the second dwarf's genome as a result. Help Dwarf Misha and find out whether two gnomes belong to the same race or not.
Input
The first line contains the first dwarf's genome: a non-empty string, consisting of lowercase Latin letters.
The second line contains the second dwarf's genome: a non-empty string, consisting of lowercase Latin letters.
The number of letters in each genome doesn't exceed 105. It is guaranteed that the strings that correspond to the genomes are different. The given genomes may have different length.
Output
Print "YES", if the dwarves belong to the same race. Otherwise, print "NO".
Examples
Input
ab
ba
Output
YES
Input
aa
ab
Output
NO
Note
* First example: you can simply swap two letters in string "ab". So we get "ba".
* Second example: we can't change string "aa" into string "ab", because "aa" does not contain letter "b". | #python33
def program():
s=0
A=list(input())
B=list(input())
for i,j in zip(A,B):
if i!=j:
s+=1
A.sort()
B.sort()
if A==B and s==2:
print ("YES")
else:
print ("NO")
program()
| {
"input": [
"ab\nba\n",
"aa\nab\n"
],
"output": [
"YES\n",
"NO\n"
]
} |
2,074 | 8 | John Doe has an n Γ m table. John Doe can paint points in some table cells, not more than one point in one table cell. John Doe wants to use such operations to make each square subtable of size n Γ n have exactly k points.
John Doe wondered, how many distinct ways to fill the table with points are there, provided that the condition must hold. As this number can be rather large, John Doe asks to find its remainder after dividing by 1000000007 (109 + 7).
You should assume that John always paints a point exactly in the center of some cell. Two ways to fill a table are considered distinct, if there exists a table cell, that has a point in one way and doesn't have it in the other.
Input
A single line contains space-separated integers n, m, k (1 β€ n β€ 100; n β€ m β€ 1018; 0 β€ k β€ n2) β the number of rows of the table, the number of columns of the table and the number of points each square must contain.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use the cin, cout streams or the %I64d specifier.
Output
In a single line print a single integer β the remainder from dividing the described number of ways by 1000000007 (109 + 7).
Examples
Input
5 6 1
Output
45
Note
Let's consider the first test case:
<image> The gray area belongs to both 5 Γ 5 squares. So, if it has one point, then there shouldn't be points in any other place. If one of the white areas has a point, then the other one also must have a point. Thus, there are about 20 variants, where the point lies in the gray area and 25 variants, where each of the white areas contains a point. Overall there are 45 variants. | n,m,k=map(int,input().split())
M=int(1e9+7)
N=n*n
iv=[0]*(N+1)
iv[1]=1
for i in range(2, N+1):
iv[i]=M-M//i*iv[M%i]%M
f1=[1]*(N+1)
for i in range(1, N+1):
f1[i]=f1[i-1]*i%M
f2=[1]*(N+1)
for i in range(1, N+1):
f2[i]=f2[i-1]*iv[i]%M
left=m%n
#m/n+1, m/n
def powM(b, p):
r=1
while p>0:
if p%2>0:
r=r*b%M
b=b*b%M
p//=2
return r
c=[[powM(f1[n]*f2[j]%M*f2[n-j]%M, m//n+i) for j in range(n+1)] for i in range(2)]
#print(c)
dp=[[0]*(k+1) for i in range(n+1)]
dp[0][0]=1
for i in range(n):
for j in range(k+1):
#prune
if j>i*n or j<k-(n-i)*n:
continue
for l in range(min(n, k-j)+1):
# i,j -> i+1,j+l
dp[i+1][j+l]=(dp[i+1][j+l]+c[i<left][l]*dp[i][j])%M
print(dp[n][k]) | {
"input": [
"5 6 1\n"
],
"output": [
" 45\n"
]
} |
2,075 | 7 | The Little Elephant has an integer a, written in the binary notation. He wants to write this number on a piece of paper.
To make sure that the number a fits on the piece of paper, the Little Elephant ought to delete exactly one any digit from number a in the binary record. At that a new number appears. It consists of the remaining binary digits, written in the corresponding order (possible, with leading zeroes).
The Little Elephant wants the number he is going to write on the paper to be as large as possible. Help him find the maximum number that he can obtain after deleting exactly one binary digit and print it in the binary notation.
Input
The single line contains integer a, written in the binary notation without leading zeroes. This number contains more than 1 and at most 105 digits.
Output
In the single line print the number that is written without leading zeroes in the binary notation β the answer to the problem.
Examples
Input
101
Output
11
Input
110010
Output
11010
Note
In the first sample the best strategy is to delete the second digit. That results in number 112 = 310.
In the second sample the best strategy is to delete the third or fourth digits β that results in number 110102 = 2610. | def solve(a):
for i in range(len(a)):
if a[i]=='0':
return a[0:i] + a[i+1:]
return a[1:]
print(solve(input()))
| {
"input": [
"110010\n",
"101\n"
],
"output": [
"11010\n",
"11\n"
]
} |
2,076 | 7 | Capitalization is writing a word with its first letter as a capital letter. Your task is to capitalize the given word.
Note, that during capitalization all the letters except the first one remains unchanged.
Input
A single line contains a non-empty word. This word consists of lowercase and uppercase English letters. The length of the word will not exceed 103.
Output
Output the given word after capitalization.
Examples
Input
ApPLe
Output
ApPLe
Input
konjac
Output
Konjac | def cp(s):
return s[0].upper()+s[1:]
print(cp(input())) | {
"input": [
"konjac\n",
"ApPLe\n"
],
"output": [
"Konjac\n",
"ApPLe\n"
]
} |
2,077 | 7 | You are given a rectangular cake, represented as an r Γ c grid. Each cell either has an evil strawberry, or is empty. For example, a 3 Γ 4 cake may look as follows:
<image>
The cakeminator is going to eat the cake! Each time he eats, he chooses a row or a column that does not contain any evil strawberries and contains at least one cake cell that has not been eaten before, and eats all the cake cells there. He may decide to eat any number of times.
Please output the maximum number of cake cells that the cakeminator can eat.
Input
The first line contains two integers r and c (2 β€ r, c β€ 10), denoting the number of rows and the number of columns of the cake. The next r lines each contains c characters β the j-th character of the i-th line denotes the content of the cell at row i and column j, and is either one of these:
* '.' character denotes a cake cell with no evil strawberry;
* 'S' character denotes a cake cell with an evil strawberry.
Output
Output the maximum number of cake cells that the cakeminator can eat.
Examples
Input
3 4
S...
....
..S.
Output
8
Note
For the first example, one possible way to eat the maximum number of cake cells is as follows (perform 3 eats).
<image> <image> <image> | def stri(t,a,b):
l=0
for i in range(b):
if t[i]=="S":
a[i]=1
l=-1
if l==0:
return 0
else:
return -1
a,b=map(int,input().split())
r=[0]*a
c=[0]*b
for i in range(a):
k=input()
t=stri(k,c,b)
if t==-1:
r[i]=1
m=r.count(0)
n=c.count(0)
print(m*b+n*a-m*n) | {
"input": [
"3 4\nS...\n....\n..S.\n"
],
"output": [
"8\n"
]
} |
2,078 | 9 | Recently a serious bug has been found in the FOS code. The head of the F company wants to find the culprit and punish him. For that, he set up an organizational meeting, the issue is: who's bugged the code? Each of the n coders on the meeting said: 'I know for sure that either x or y did it!'
The head of the company decided to choose two suspects and invite them to his office. Naturally, he should consider the coders' opinions. That's why the head wants to make such a choice that at least p of n coders agreed with it. A coder agrees with the choice of two suspects if at least one of the two people that he named at the meeting was chosen as a suspect. In how many ways can the head of F choose two suspects?
Note that even if some coder was chosen as a suspect, he can agree with the head's choice if he named the other chosen coder at the meeting.
Input
The first line contains integers n and p (3 β€ n β€ 3Β·105; 0 β€ p β€ n) β the number of coders in the F company and the minimum number of agreed people.
Each of the next n lines contains two integers xi, yi (1 β€ xi, yi β€ n) β the numbers of coders named by the i-th coder. It is guaranteed that xi β i, yi β i, xi β yi.
Output
Print a single integer ββ the number of possible two-suspect sets. Note that the order of the suspects doesn't matter, that is, sets (1, 2) ΠΈ (2, 1) are considered identical.
Examples
Input
4 2
2 3
1 4
1 4
2 1
Output
6
Input
8 6
5 6
5 7
5 8
6 2
2 1
7 3
1 3
1 4
Output
1 | from collections import defaultdict
from bisect import bisect_left as lower
import sys
input = sys.stdin.readline
def put():
return map(int, input().split())
try:
n,m = put()
cnt, mp, ans = [0]*n, defaultdict(), [0]*n
for _ in range(n):
x,y = put()
x,y = x-1,y-1
key = (min(x,y), max(x,y))
if key in mp:
mp[key]+=1
else:
mp[key]=1
cnt[x]+=1
cnt[y]+=1
except:
print('lol')
for (x,y),val in mp.items():
if cnt[x]+cnt[y]>= m and cnt[x]+cnt[y]-val<m:
ans[x]-=1
ans[y]-=1
scnt = cnt.copy()
scnt.sort()
for i in range(n):
ans[i]+= n-lower(scnt, m-cnt[i])
if 2*cnt[i]>=m:
ans[i]-=1
print(sum(ans)//2)
| {
"input": [
"8 6\n5 6\n5 7\n5 8\n6 2\n2 1\n7 3\n1 3\n1 4\n",
"4 2\n2 3\n1 4\n1 4\n2 1\n"
],
"output": [
"1\n",
"6\n"
]
} |
2,079 | 7 | DZY has a hash table with p buckets, numbered from 0 to p - 1. He wants to insert n numbers, in the order they are given, into the hash table. For the i-th number xi, DZY will put it into the bucket numbered h(xi), where h(x) is the hash function. In this problem we will assume, that h(x) = x mod p. Operation a mod b denotes taking a remainder after division a by b.
However, each bucket can contain no more than one element. If DZY wants to insert an number into a bucket which is already filled, we say a "conflict" happens. Suppose the first conflict happens right after the i-th insertion, you should output i. If no conflict happens, just output -1.
Input
The first line contains two integers, p and n (2 β€ p, n β€ 300). Then n lines follow. The i-th of them contains an integer xi (0 β€ xi β€ 109).
Output
Output a single integer β the answer to the problem.
Examples
Input
10 5
0
21
53
41
53
Output
4
Input
5 5
0
1
2
3
4
Output
-1 | p,n=input().split()
n=int(n)
p=int(p)
def f(n,p):
l=[]
for i in range(1,n+1):
a=int(input())%p
if a in l:
return i
l.append(a)
return -1
print(f(n,p)) | {
"input": [
"10 5\n0\n21\n53\n41\n53\n",
"5 5\n0\n1\n2\n3\n4\n"
],
"output": [
"4",
"-1"
]
} |
2,080 | 8 | Little X and Little Z are good friends. They always chat online. But both of them have schedules.
Little Z has fixed schedule. He always online at any moment of time between a1 and b1, between a2 and b2, ..., between ap and bp (all borders inclusive). But the schedule of Little X is quite strange, it depends on the time when he gets up. If he gets up at time 0, he will be online at any moment of time between c1 and d1, between c2 and d2, ..., between cq and dq (all borders inclusive). But if he gets up at time t, these segments will be shifted by t. They become [ci + t, di + t] (for all i).
If at a moment of time, both Little X and Little Z are online simultaneosly, they can chat online happily. You know that Little X can get up at an integer moment of time between l and r (both borders inclusive). Also you know that Little X wants to get up at the moment of time, that is suitable for chatting with Little Z (they must have at least one common moment of time in schedules). How many integer moments of time from the segment [l, r] suit for that?
Input
The first line contains four space-separated integers p, q, l, r (1 β€ p, q β€ 50; 0 β€ l β€ r β€ 1000).
Each of the next p lines contains two space-separated integers ai, bi (0 β€ ai < bi β€ 1000). Each of the next q lines contains two space-separated integers cj, dj (0 β€ cj < dj β€ 1000).
It's guaranteed that bi < ai + 1 and dj < cj + 1 for all valid i and j.
Output
Output a single integer β the number of moments of time from the segment [l, r] which suit for online conversation.
Examples
Input
1 1 0 4
2 3
0 1
Output
3
Input
2 3 0 20
15 17
23 26
1 4
7 11
15 17
Output
20 | def shift(S, i): return set(x+i for x in S)
p, q, l, r = [int(x) for x in input().split()]
P, Q = set(), set()
for i in range(p):
a, b = [int(x) for x in input().split()]
P.update(range(a,b+1))
for i in range(q):
a, b = [int(x) for x in input().split()]
Q.update(range(a,b+1))
ans = 0
for i in range(l, r+1):
if shift(Q,i)&P: ans += 1
print(ans)
| {
"input": [
"1 1 0 4\n2 3\n0 1\n",
"2 3 0 20\n15 17\n23 26\n1 4\n7 11\n15 17\n"
],
"output": [
"3\n",
"20\n"
]
} |
2,081 | 7 | Hiking club "Up the hill" just returned from a walk. Now they are trying to remember which hills they've just walked through.
It is known that there were N stops, all on different integer heights between 1 and N kilometers (inclusive) above the sea level. On the first day they've traveled from the first stop to the second stop, on the second day they've traveled from the second to the third and so on, and on the last day they've traveled from the stop N - 1 to the stop N and successfully finished their expedition.
They are trying to find out which heights were their stops located at. They have an entry in a travel journal specifying how many days did they travel up the hill, and how many days did they walk down the hill.
Help them by suggesting some possible stop heights satisfying numbers from the travel journal.
Input
In the first line there is an integer non-negative number A denoting the number of days of climbing up the hill. Second line contains an integer non-negative number B β the number of days of walking down the hill (A + B + 1 = N, 1 β€ N β€ 100 000).
Output
Output N space-separated distinct integers from 1 to N inclusive, denoting possible heights of the stops in order of visiting.
Examples
Input
0
1
Output
2 1
Input
2
1
Output
1 3 4 2 | def mountain(a, b):
z = list()
for i in range(1, a + 1):
z.append(i)
for i in range(a + b + 1, a, -1):
z.append(i)
return z
A = int(input())
B = int(input())
print(*mountain(A, B))
| {
"input": [
"0\n1\n",
"2\n1"
],
"output": [
"2 1 ",
"2 3 4 1 "
]
} |
2,082 | 8 | Drazil has many friends. Some of them are happy and some of them are unhappy. Drazil wants to make all his friends become happy. So he invented the following plan.
There are n boys and m girls among his friends. Let's number them from 0 to n - 1 and 0 to m - 1 separately. In i-th day, Drazil invites <image>-th boy and <image>-th girl to have dinner together (as Drazil is programmer, i starts from 0). If one of those two people is happy, the other one will also become happy. Otherwise, those two people remain in their states. Once a person becomes happy (or if he/she was happy originally), he stays happy forever.
Drazil wants to know whether he can use this plan to make all his friends become happy at some moment.
Input
The first line contains two integer n and m (1 β€ n, m β€ 100).
The second line contains integer b (0 β€ b β€ n), denoting the number of happy boys among friends of Drazil, and then follow b distinct integers x1, x2, ..., xb (0 β€ xi < n), denoting the list of indices of happy boys.
The third line conatins integer g (0 β€ g β€ m), denoting the number of happy girls among friends of Drazil, and then follow g distinct integers y1, y2, ... , yg (0 β€ yj < m), denoting the list of indices of happy girls.
It is guaranteed that there is at least one person that is unhappy among his friends.
Output
If Drazil can make all his friends become happy by this plan, print "Yes". Otherwise, print "No".
Examples
Input
2 3
0
1 0
Output
Yes
Input
2 4
1 0
1 2
Output
No
Input
2 3
1 0
1 1
Output
Yes
Note
By <image> we define the remainder of integer division of i by k.
In first sample case:
* On the 0-th day, Drazil invites 0-th boy and 0-th girl. Because 0-th girl is happy at the beginning, 0-th boy become happy at this day.
* On the 1-st day, Drazil invites 1-st boy and 1-st girl. They are both unhappy, so nothing changes at this day.
* On the 2-nd day, Drazil invites 0-th boy and 2-nd girl. Because 0-th boy is already happy he makes 2-nd girl become happy at this day.
* On the 3-rd day, Drazil invites 1-st boy and 0-th girl. 0-th girl is happy, so she makes 1-st boy happy.
* On the 4-th day, Drazil invites 0-th boy and 1-st girl. 0-th boy is happy, so he makes the 1-st girl happy. So, all friends become happy at this moment. | import fractions as f
def i():
return list(map(int,input().split()))
n,m=i()
a=f.gcd(m,n)
p=i()
q=i()
b=len(p)
z=set()
for e in q:p.append(e)
for i in range(len(p)-2):z.add(p[i+1+min(1,(i+1)//b)]%a)
print(['No','Yes'][len(z)==a])
# Made By Mostafa_Khaled | {
"input": [
"2 3\n0\n1 0\n",
"2 3\n1 0\n1 1\n",
"2 4\n1 0\n1 2\n"
],
"output": [
"Yes\n",
"Yes\n",
"No\n"
]
} |
2,083 | 9 | Some time ago Leonid have known about idempotent functions. Idempotent function defined on a set {1, 2, ..., n} is such function <image>, that for any <image> the formula g(g(x)) = g(x) holds.
Let's denote as f(k)(x) the function f applied k times to the value x. More formally, f(1)(x) = f(x), f(k)(x) = f(f(k - 1)(x)) for each k > 1.
You are given some function <image>. Your task is to find minimum positive integer k such that function f(k)(x) is idempotent.
Input
In the first line of the input there is a single integer n (1 β€ n β€ 200) β the size of function f domain.
In the second line follow f(1), f(2), ..., f(n) (1 β€ f(i) β€ n for each 1 β€ i β€ n), the values of a function.
Output
Output minimum k such that function f(k)(x) is idempotent.
Examples
Input
4
1 2 2 4
Output
1
Input
3
2 3 3
Output
2
Input
3
2 3 1
Output
3
Note
In the first sample test function f(x) = f(1)(x) is already idempotent since f(f(1)) = f(1) = 1, f(f(2)) = f(2) = 2, f(f(3)) = f(3) = 2, f(f(4)) = f(4) = 4.
In the second sample test:
* function f(x) = f(1)(x) isn't idempotent because f(f(1)) = 3 but f(1) = 2;
* function f(x) = f(2)(x) is idempotent since for any x it is true that f(2)(x) = 3, so it is also true that f(2)(f(2)(x)) = 3.
In the third sample test:
* function f(x) = f(1)(x) isn't idempotent because f(f(1)) = 3 but f(1) = 2;
* function f(f(x)) = f(2)(x) isn't idempotent because f(2)(f(2)(1)) = 2 but f(2)(1) = 3;
* function f(f(f(x))) = f(3)(x) is idempotent since it is identity function: f(3)(x) = x for any <image> meaning that the formula f(3)(f(3)(x)) = f(3)(x) also holds. | def gcd(x, y):
if y == 0:
return x
return gcd(y, x % y)
n = int(input())
v = [(int(i) - 1) for i in input().split()]
b = [0] * n
r = 1
for i in range(n):
j, k = 1, v[i]
while j <= 2 * n + 10 and k != i:
k = v[k]
j += 1
if k == i:
r *= j // gcd(r, j)
b[i] = 1
z = 0
for i in range(n):
j, k = 0, i
while not b[k]:
k = v[k]
j += 1
z = max(z, j)
j = z
if j > r:
k = j // r
if j % r != 0:
k += 1
r *= k
print(r) | {
"input": [
"3\n2 3 3\n",
"3\n2 3 1\n",
"4\n1 2 2 4\n"
],
"output": [
"2\n",
"3\n",
"1\n"
]
} |
2,084 | 10 | Little Johnny has recently learned about set theory. Now he is studying binary relations. You've probably heard the term "equivalence relation". These relations are very important in many areas of mathematics. For example, the equality of the two numbers is an equivalence relation.
A set Ο of pairs (a, b) of elements of some set A is called a binary relation on set A. For two elements a and b of the set A we say that they are in relation Ο, if pair <image>, in this case we use a notation <image>.
Binary relation is equivalence relation, if:
1. It is reflexive (for any a it is true that <image>);
2. It is symmetric (for any a, b it is true that if <image>, then <image>);
3. It is transitive (if <image> and <image>, than <image>).
Little Johnny is not completely a fool and he noticed that the first condition is not necessary! Here is his "proof":
Take any two elements, a and b. If <image>, then <image> (according to property (2)), which means <image> (according to property (3)).
It's very simple, isn't it? However, you noticed that Johnny's "proof" is wrong, and decided to show him a lot of examples that prove him wrong.
Here's your task: count the number of binary relations over a set of size n such that they are symmetric, transitive, but not an equivalence relations (i.e. they are not reflexive).
Since their number may be very large (not 0, according to Little Johnny), print the remainder of integer division of this number by 109 + 7.
Input
A single line contains a single integer n (1 β€ n β€ 4000).
Output
In a single line print the answer to the problem modulo 109 + 7.
Examples
Input
1
Output
1
Input
2
Output
3
Input
3
Output
10
Note
If n = 1 there is only one such relation β an empty one, i.e. <image>. In other words, for a single element x of set A the following is hold: <image>.
If n = 2 there are three such relations. Let's assume that set A consists of two elements, x and y. Then the valid relations are <image>, Ο = {(x, x)}, Ο = {(y, y)}. It is easy to see that the three listed binary relations are symmetric and transitive relations, but they are not equivalence relations. | def main():
mod = 10 ** 9 + 7
n = int(input())
a = [[0] * (n + 1) for i in range(n + 1)]
a[0][0] = 1
for i in range(1, n + 1):
a[i][0] = a[i - 1][i - 1]
for j in range(1, i + 1):
a[i][j] = (a[i][j - 1] + a[i - 1][j - 1]) % mod
print(a[n][n - 1])
main() | {
"input": [
"2\n",
"3\n",
"1\n"
],
"output": [
"3\n",
"10\n",
"1\n"
]
} |
2,085 | 8 | A team of furry rescue rangers was sitting idle in their hollow tree when suddenly they received a signal of distress. In a few moments they were ready, and the dirigible of the rescue chipmunks hit the road.
We assume that the action takes place on a Cartesian plane. The headquarters of the rescuers is located at point (x1, y1), and the distress signal came from the point (x2, y2).
Due to Gadget's engineering talent, the rescuers' dirigible can instantly change its current velocity and direction of movement at any moment and as many times as needed. The only limitation is: the speed of the aircraft relative to the air can not exceed <image> meters per second.
Of course, Gadget is a true rescuer and wants to reach the destination as soon as possible. The matter is complicated by the fact that the wind is blowing in the air and it affects the movement of the dirigible. According to the weather forecast, the wind will be defined by the vector (vx, vy) for the nearest t seconds, and then will change to (wx, wy). These vectors give both the direction and velocity of the wind. Formally, if a dirigible is located at the point (x, y), while its own velocity relative to the air is equal to zero and the wind (ux, uy) is blowing, then after <image> seconds the new position of the dirigible will be <image>.
Gadget is busy piloting the aircraft, so she asked Chip to calculate how long will it take them to reach the destination if they fly optimally. He coped with the task easily, but Dale is convinced that Chip has given the random value, aiming only not to lose the face in front of Gadget. Dale has asked you to find the right answer.
It is guaranteed that the speed of the wind at any moment of time is strictly less than the maximum possible speed of the airship relative to the air.
Input
The first line of the input contains four integers x1, y1, x2, y2 (|x1|, |y1|, |x2|, |y2| β€ 10 000) β the coordinates of the rescuers' headquarters and the point, where signal of the distress came from, respectively.
The second line contains two integers <image> and t (0 < v, t β€ 1000), which are denoting the maximum speed of the chipmunk dirigible relative to the air and the moment of time when the wind changes according to the weather forecast, respectively.
Next follow one per line two pairs of integer (vx, vy) and (wx, wy), describing the wind for the first t seconds and the wind that will blow at all the remaining time, respectively. It is guaranteed that <image> and <image>.
Output
Print a single real value β the minimum time the rescuers need to get to point (x2, y2). You answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct, if <image>.
Examples
Input
0 0 5 5
3 2
-1 -1
-1 0
Output
3.729935587093555327
Input
0 0 0 1000
100 1000
-50 0
50 0
Output
11.547005383792516398 | f = lambda: map(int, input().split())
a, b, c, d = f()
s, t = f()
vx, vy = f()
ux, uy = f()
def g(m):
vt = min(t, m)
ut = max(0, m - t)
x = c - a - ut * ux - vt * vx
y = d - b - ut * uy - vt * vy
return x * x + y * y > (m * s) ** 2
l, r = 0, 1e9
while r - l > 1e-6:
m = (l + r) / 2
if g(m): l = m
else: r = m
print(r) | {
"input": [
"0 0 0 1000\n100 1000\n-50 0\n50 0\n",
"0 0 5 5\n3 2\n-1 -1\n-1 0\n"
],
"output": [
"11.547005",
"3.729936"
]
} |
2,086 | 7 | You are given the string s of length n and the numbers p, q. Split the string s to pieces of length p and q.
For example, the string "Hello" for p = 2, q = 3 can be split to the two strings "Hel" and "lo" or to the two strings "He" and "llo".
Note it is allowed to split the string s to the strings only of length p or to the strings only of length q (see the second sample test).
Input
The first line contains three positive integers n, p, q (1 β€ p, q β€ n β€ 100).
The second line contains the string s consists of lowercase and uppercase latin letters and digits.
Output
If it's impossible to split the string s to the strings of length p and q print the only number "-1".
Otherwise in the first line print integer k β the number of strings in partition of s.
Each of the next k lines should contain the strings in partition. Each string should be of the length p or q. The string should be in order of their appearing in string s β from left to right.
If there are several solutions print any of them.
Examples
Input
5 2 3
Hello
Output
2
He
llo
Input
10 9 5
Codeforces
Output
2
Codef
orces
Input
6 4 5
Privet
Output
-1
Input
8 1 1
abacabac
Output
8
a
b
a
c
a
b
a
c | def ft():
n, p, q = map(int,input().split())
ch = input()
for k in range(n):
if n-k*p < 0:
break
if (n-k*p)%q==0:
z = (n-k*p)//q
cp=0
T=[]
for i in range(k):
T.append(ch[cp:cp+p])
cp += p
for i in range(z):
T.append(ch[cp:cp+q])
cp += q
print(len(T))
for j in T:
print(j)
return
print(-1)
ft() | {
"input": [
"10 9 5\nCodeforces\n",
"8 1 1\nabacabac\n",
"6 4 5\nPrivet\n",
"5 2 3\nHello\n"
],
"output": [
"2\nCodef\norces\n",
"8\na\nb\na\nc\na\nb\na\nc\n",
"-1\n",
"2\nHe\nllo\n"
]
} |
2,087 | 7 | Grandma Laura came to the market to sell some apples. During the day she sold all the apples she had. But grandma is old, so she forgot how many apples she had brought to the market.
She precisely remembers she had n buyers and each of them bought exactly half of the apples she had at the moment of the purchase and also she gave a half of an apple to some of them as a gift (if the number of apples at the moment of purchase was odd), until she sold all the apples she had.
So each buyer took some integral positive number of apples, but maybe he didn't pay for a half of an apple (if the number of apples at the moment of the purchase was odd).
For each buyer grandma remembers if she gave a half of an apple as a gift or not. The cost of an apple is p (the number p is even).
Print the total money grandma should have at the end of the day to check if some buyers cheated her.
Input
The first line contains two integers n and p (1 β€ n β€ 40, 2 β€ p β€ 1000) β the number of the buyers and the cost of one apple. It is guaranteed that the number p is even.
The next n lines contains the description of buyers. Each buyer is described with the string half if he simply bought half of the apples and with the string halfplus if grandma also gave him a half of an apple as a gift.
It is guaranteed that grandma has at least one apple at the start of the day and she has no apples at the end of the day.
Output
Print the only integer a β the total money grandma should have at the end of the day.
Note that the answer can be too large, so you should use 64-bit integer type to store it. In C++ you can use the long long integer type and in Java you can use long integer type.
Examples
Input
2 10
half
halfplus
Output
15
Input
3 10
halfplus
halfplus
halfplus
Output
55
Note
In the first sample at the start of the day the grandma had two apples. First she sold one apple and then she sold a half of the second apple and gave a half of the second apple as a present to the second buyer. | def main():
n, p = map(int, input().split())
res = x = 0
for f in reversed([input() == "halfplus" for _ in range(n)]):
res += x * 2
x *= 2
if f:
res += 1
x += 1
print(res * p // 2)
if __name__ == '__main__':
main()
| {
"input": [
"2 10\nhalf\nhalfplus\n",
"3 10\nhalfplus\nhalfplus\nhalfplus\n"
],
"output": [
"15\n",
"55\n"
]
} |
2,088 | 10 | You are given n points on a plane. All the points are distinct and no three of them lie on the same line. Find the number of parallelograms with the vertices at the given points.
Input
The first line of the input contains integer n (1 β€ n β€ 2000) β the number of points.
Each of the next n lines contains two integers (xi, yi) (0 β€ xi, yi β€ 109) β the coordinates of the i-th point.
Output
Print the only integer c β the number of parallelograms with the vertices at the given points.
Example
Input
4
0 1
1 0
1 1
2 0
Output
1 | def main():
from collections import Counter
n, cnt, l = int(input()), Counter(), []
for x, y in sorted((tuple(map(int, input().split())) for _ in range(n)), reverse=True):
for u, v in l:
cnt[u - x, v - y] += 1
l.append((x, y))
print(sum(i * (i - 1) for i in cnt.values()) // 4)
if __name__ == '__main__':
main()
| {
"input": [
"4\n0 1\n1 0\n1 1\n2 0\n"
],
"output": [
"1\n"
]
} |
2,089 | 8 | Masha wants to open her own bakery and bake muffins in one of the n cities numbered from 1 to n. There are m bidirectional roads, each of whose connects some pair of cities.
To bake muffins in her bakery, Masha needs to establish flour supply from some storage. There are only k storages, located in different cities numbered a1, a2, ..., ak.
Unforunately the law of the country Masha lives in prohibits opening bakery in any of the cities which has storage located in it. She can open it only in one of another n - k cities, and, of course, flour delivery should be paid β for every kilometer of path between storage and bakery Masha should pay 1 ruble.
Formally, Masha will pay x roubles, if she will open the bakery in some city b (ai β b for every 1 β€ i β€ k) and choose a storage in some city s (s = aj for some 1 β€ j β€ k) and b and s are connected by some path of roads of summary length x (if there are more than one path, Masha is able to choose which of them should be used).
Masha is very thrifty and rational. She is interested in a city, where she can open her bakery (and choose one of k storages and one of the paths between city with bakery and city with storage) and pay minimum possible amount of rubles for flour delivery. Please help Masha find this amount.
Input
The first line of the input contains three integers n, m and k (1 β€ n, m β€ 105, 0 β€ k β€ n) β the number of cities in country Masha lives in, the number of roads between them and the number of flour storages respectively.
Then m lines follow. Each of them contains three integers u, v and l (1 β€ u, v β€ n, 1 β€ l β€ 109, u β v) meaning that there is a road between cities u and v of length of l kilometers .
If k > 0, then the last line of the input contains k distinct integers a1, a2, ..., ak (1 β€ ai β€ n) β the number of cities having flour storage located in. If k = 0 then this line is not presented in the input.
Output
Print the minimum possible amount of rubles Masha should pay for flour delivery in the only line.
If the bakery can not be opened (while satisfying conditions) in any of the n cities, print - 1 in the only line.
Examples
Input
5 4 2
1 2 5
1 2 3
2 3 4
1 4 10
1 5
Output
3
Input
3 1 1
1 2 3
3
Output
-1
Note
<image>
Image illustrates the first sample case. Cities with storage located in and the road representing the answer are darkened. | import sys
def get_ints(): return map(int, sys.stdin.readline().split())
#def get_list(): return list(map(int, sys.stdin.readline().split()))
n,m,k=get_ints()
t=[list(get_ints()) for _ in range(m)]
a=set(get_ints()) if k else []
x=[l for u,v,l in t if (u in a)^(v in a)]
print(min(x) if x else -1)
| {
"input": [
"5 4 2\n1 2 5\n1 2 3\n2 3 4\n1 4 10\n1 5\n",
"3 1 1\n1 2 3\n3\n"
],
"output": [
"3",
"-1"
]
} |
2,090 | 11 | There is a square box 6 Γ 6 in size. It contains 36 chips 1 Γ 1 in size. Those chips contain 36 different characters β "0"-"9" and "A"-"Z". There is exactly one chip with each character.
You are allowed to make the following operations: you may choose one of 6 rows or one of 6 columns and cyclically shift the chips there to one position to the left or to the right (for the row) or upwards or downwards (for the column). Those operations are allowed to perform several times.
To solve the puzzle is to shift the chips using the above described operations so that they were written in the increasing order (exactly equal to the right picture). An example of solving the puzzle is shown on a picture below.
<image>
Write a program that finds the sequence of operations that solves the puzzle. That sequence should not necessarily be shortest, but you should not exceed the limit of 10000 operations. It is guaranteed that the solution always exists.
Input
The input data are represented by 6 lines containing 6 characters each. They are the puzzle's initial position. Those lines contain each character from the string "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ" exactly once.
Output
On the first line print number n, which is the number of operations. On the next n lines print the sequence of operations one per line. An operation is described by a word consisting of two characters. The first character shows the direction where the row or the column will be shifted. The possible directions are "L", "R" (to the left, to the right correspondingly, we shift a row), "U", "D" (upwards, downwards correspondingly, we shift a column). The second character is the number of the row (or the column), it is an integer from "1" to "6". The rows are numbered from the top to the bottom, the columns are numbered from the left to the right.
The number of operations should not exceed 104. If there are several solutions, print any of them.
Examples
Input
01W345
729AB6
CD8FGH
IJELMN
OPKRST
UVQXYZ
Output
2
R2
U3 | ls="0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
s,cnt,a1,a2=[],0,[],[]
for i in range(6):
s.append(list(input()))
def add(c,i):
global cnt
cnt+=1
a1.append(c)
a2.append(i)
def right(i):
add('R',i+1)
tmp=s[i][5]
for j in range(5,0,-1):
s[i][j]=s[i][j-1]
s[i][0]=tmp
def left(i):
add('L',i+1)
tmp=s[i][0]
for j in range(5):
s[i][j]=s[i][j+1]
s[i][5]=tmp
def up(j):
add('U',j+1)
tmp=s[0][j]
for i in range(5):
s[i][j]=s[i+1][j]
s[5][j]=tmp
def down(j):
add('D',j+1)
tmp=s[5][j]
for i in range(5,0,-1):
s[i][j]=s[i-1][j]
s[0][j]=tmp
def chg(i1,j1,i2,j2):
if i1==i2:
right(i1);up(j1);right(i1);down(j1)
right(i1);up(j1);right(i1);down(j1)
right(i1);up(j1);right(i1);right(i1);down(j1)
else:
down(j1);left(i1);down(j1);right(i1)
down(j1);left(i1);down(j1);right(i1)
down(j1);left(i1);down(j1);down(j1);right(i1)
for i in range(6):
for j in range(6):
toch=ls[i*6+j]
for ni in range(6):
for nj in range(6):
if s[ni][nj]==toch:
ii,jj=ni,nj
while jj>j:
chg(ii,jj-1,ii,jj)
jj-=1
while jj<j:
chg(ii,jj,ii,jj+1)
jj+=1
while ii>i:
chg(ii-1,jj,ii,jj)
ii-=1
print(cnt)
for i in range(cnt):
print(a1[i]+str(a2[i])) | {
"input": [
"01W345\n729AB6\nCD8FGH\nIJELMN\nOPKRST\nUVQXYZ\n"
],
"output": [
"260\nD3\nR2\nD3\nL2\nD3\nR2\nD3\nL2\nD3\nR2\nD3\nL2\nD3\nR2\nD3\nR2\nU3\nR2\nD3\nR2\nU3\nR2\nD3\nR2\nU3\nR2\nD6\nR2\nD6\nL2\nD6\nR2\nD6\nL2\nD6\nR2\nD6\nL2\nD6\nD5\nR2\nD5\nL2\nD5\nR2\nD5\nL2\nD5\nR2\nD5\nL2\nD5\nD4\nR2\nD4\nL2\nD4\nR2\nD4\nL2\nD4\nR2\nD4\nL2\nD4\nD3\nR2\nD3\nL2\nD3\nR2\nD3\nL2\nD3\nR2\nD3\nL2\nD3\nD2\nR2\nD2\nL2\nD2\nR2\nD2\nL2\nD2\nR2\nD2\nL2\nD2\nR3\nD3\nR3\nU3\nR3\nD3\nR3\nU3\nR3\nD3\nR3\nU3\nR3\nD4\nR3\nD4\nL3\nD4\nR3\nD4\nL3\nD4\nR3\nD4\nL3\nD4\nR3\nD4\nR3\nU4\nR3\nD4\nR3\nU4\nR3\nD4\nR3\nU4\nR3\nR4\nD3\nR4\nU3\nR4\nD3\nR4\nU3\nR4\nD3\nR4\nU3\nR4\nD4\nR4\nD4\nL4\nD4\nR4\nD4\nL4\nD4\nR4\nD4\nL4\nD4\nR4\nD4\nR4\nU4\nR4\nD4\nR4\nU4\nR4\nD4\nR4\nU4\nR4\nR5\nD3\nR5\nU3\nR5\nD3\nR5\nU3\nR5\nD3\nR5\nU3\nR5\nD4\nR5\nD4\nL5\nD4\nR5\nD4\nL5\nD4\nR5\nD4\nL5\nD4\nR5\nD4\nR5\nU4\nR5\nD4\nR5\nU4\nR5\nD4\nR5\nU4\nR5\nR6\nD3\nR6\nU3\nR6\nD3\nR6\nU3\nR6\nD3\nR6\nU3\nR6\nD4\nR6\nD4\nL6\nD4\nR6\nD4\nL6\nD4\nR6\nD4\nL6\nD4\nR6\nD4\nR6\nU4\nR6\nD4\nR6\nU4\nR6\nD4\nR6\nU4\nR6\nD4\nR6\nD4\nL6\nD4\nR6\nD4\nL6\nD4\nR6\nD4\nL6\nD4\n"
]
} |
2,091 | 9 | Mike has a sequence A = [a1, a2, ..., an] of length n. He considers the sequence B = [b1, b2, ..., bn] beautiful if the gcd of all its elements is bigger than 1, i.e. <image>.
Mike wants to change his sequence in order to make it beautiful. In one move he can choose an index i (1 β€ i < n), delete numbers ai, ai + 1 and put numbers ai - ai + 1, ai + ai + 1 in their place instead, in this order. He wants perform as few operations as possible. Find the minimal number of operations to make sequence A beautiful if it's possible, or tell him that it is impossible to do so.
<image> is the biggest non-negative number d such that d divides bi for every i (1 β€ i β€ n).
Input
The first line contains a single integer n (2 β€ n β€ 100 000) β length of sequence A.
The second line contains n space-separated integers a1, a2, ..., an (1 β€ ai β€ 109) β elements of sequence A.
Output
Output on the first line "YES" (without quotes) if it is possible to make sequence A beautiful by performing operations described above, and "NO" (without quotes) otherwise.
If the answer was "YES", output the minimal number of moves needed to make sequence A beautiful.
Examples
Input
2
1 1
Output
YES
1
Input
3
6 2 4
Output
YES
0
Input
2
1 3
Output
YES
1
Note
In the first example you can simply make one move to obtain sequence [0, 2] with <image>.
In the second example the gcd of the sequence is already greater than 1. | def GCD(a,b):
return a if b == 0 else GCD(b,a%b)
n = int(input())
a = list(map(int,input().split()))
a.append(0)
g=0
odds =0
count = 0
for i in range(n+1):
g = GCD(a[i],g)
if a[i] % 2 == 1 :
odds += 1
else:
count += (odds // 2) + 2 * (odds % 2)
odds = 0
print("YES")
print(0 if g > 1 else count)
| {
"input": [
"2\n1 1\n",
"2\n1 3\n",
"3\n6 2 4\n"
],
"output": [
"YES\n1\n",
"YES\n1\n",
"YES\n0\n"
]
} |
2,092 | 11 | Vova again tries to play some computer card game.
The rules of deck creation in this game are simple. Vova is given an existing deck of n cards and a magic number k. The order of the cards in the deck is fixed. Each card has a number written on it; number ai is written on the i-th card in the deck.
After receiving the deck and the magic number, Vova removes x (possibly x = 0) cards from the top of the deck, y (possibly y = 0) cards from the bottom of the deck, and the rest of the deck is his new deck (Vova has to leave at least one card in the deck after removing cards). So Vova's new deck actually contains cards x + 1, x + 2, ... n - y - 1, n - y from the original deck.
Vova's new deck is considered valid iff the product of all numbers written on the cards in his new deck is divisible by k. So Vova received a deck (possibly not a valid one) and a number k, and now he wonders, how many ways are there to choose x and y so the deck he will get after removing x cards from the top and y cards from the bottom is valid?
Input
The first line contains two integers n and k (1 β€ n β€ 100 000, 1 β€ k β€ 109).
The second line contains n integers a1, a2, ..., an (1 β€ ai β€ 109) β the numbers written on the cards.
Output
Print the number of ways to choose x and y so the resulting deck is valid.
Examples
Input
3 4
6 2 8
Output
4
Input
3 6
9 1 14
Output
1
Note
In the first example the possible values of x and y are:
1. x = 0, y = 0;
2. x = 1, y = 0;
3. x = 2, y = 0;
4. x = 0, y = 1. | def gcd(a,b):
if a == 0:
return b
return gcd(b%a,a)
n,k = [int(x) for x in input().split()]
a = [gcd(int(x),k) for x in input().split()]
if k == 1:
print(((n+1)*(n+2))//2-n-1)
else:
s = 0
e = 0
total = ((n+1)*(n+2))//2-1-n
#print(total)
#extra = {}
c = 1
while e < n:
flag = False
while c%k != 0 and e < n:
total -= e-s
c *= a[e]
e += 1
while c%k == 0 and s < e:
c //= a[s]
s += 1
total -= e-s
print(total)
| {
"input": [
"3 4\n6 2 8\n",
"3 6\n9 1 14\n"
],
"output": [
"4\n",
"1\n"
]
} |
2,093 | 7 | Calculate the minimum number of characters you need to change in the string s, so that it contains at least k different letters, or print that it is impossible.
String s consists only of lowercase Latin letters, and it is allowed to change characters only to lowercase Latin letters too.
Input
First line of input contains string s, consisting only of lowercase Latin letters (1 β€ |s| β€ 1000, |s| denotes the length of s).
Second line of input contains integer k (1 β€ k β€ 26).
Output
Print single line with a minimum number of necessary changes, or the word Β«impossibleΒ» (without quotes) if it is impossible.
Examples
Input
yandex
6
Output
0
Input
yahoo
5
Output
1
Input
google
7
Output
impossible
Note
In the first test case string contains 6 different letters, so we don't need to change anything.
In the second test case string contains 4 different letters: {'a', 'h', 'o', 'y'}. To get 5 different letters it is necessary to change one occurrence of 'o' to some letter, which doesn't occur in the string, for example, {'b'}.
In the third test case, it is impossible to make 7 different letters because the length of the string is 6. | def sol():
s = input()
k = int(input())
if k > len(s):
print("impossible")
else:
s = set(s)
print(max(0, k - len(s)))
sol() | {
"input": [
"yahoo\n5\n",
"google\n7\n",
"yandex\n6\n"
],
"output": [
"1\n",
"impossible\n",
"0\n"
]
} |
2,094 | 10 | Ivan has an array consisting of n elements. Each of the elements is an integer from 1 to n.
Recently Ivan learned about permutations and their lexicographical order. Now he wants to change (replace) minimum number of elements in his array in such a way that his array becomes a permutation (i.e. each of the integers from 1 to n was encountered in his array exactly once). If there are multiple ways to do it he wants to find the lexicographically minimal permutation among them.
Thus minimizing the number of changes has the first priority, lexicographical minimizing has the second priority.
In order to determine which of the two permutations is lexicographically smaller, we compare their first elements. If they are equal β compare the second, and so on. If we have two permutations x and y, then x is lexicographically smaller if xi < yi, where i is the first index in which the permutations x and y differ.
Determine the array Ivan will obtain after performing all the changes.
Input
The first line contains an single integer n (2 β€ n β€ 200 000) β the number of elements in Ivan's array.
The second line contains a sequence of integers a1, a2, ..., an (1 β€ ai β€ n) β the description of Ivan's array.
Output
In the first line print q β the minimum number of elements that need to be changed in Ivan's array in order to make his array a permutation. In the second line, print the lexicographically minimal permutation which can be obtained from array with q changes.
Examples
Input
4
3 2 2 3
Output
2
1 2 4 3
Input
6
4 5 6 3 2 1
Output
0
4 5 6 3 2 1
Input
10
6 8 4 6 7 1 6 3 4 5
Output
3
2 8 4 6 7 1 9 3 10 5
Note
In the first example Ivan needs to replace number three in position 1 with number one, and number two in position 3 with number four. Then he will get a permutation [1, 2, 4, 3] with only two changed numbers β this permutation is lexicographically minimal among all suitable.
In the second example Ivan does not need to change anything because his array already is a permutation. | from collections import Counter
def f(a,n):
cnt=Counter(a)
l=[]
for i in range(1,n+1):
if cnt[i]==0:
l.append(i)
lo=0
c=0
left=set()
for i in range(n):
if cnt[a[i]]>1 :
if l[lo]<a[i] or (a[i]in left):
cnt[a[i]]-=1
a[i]=l[lo]
lo+=1
c+=1
else:
left.add(a[i])
print(c)
print(*a)
n=int(input())
l=list(map(int,input().strip().split()))
f(l,n) | {
"input": [
"4\n3 2 2 3\n",
"6\n4 5 6 3 2 1\n",
"10\n6 8 4 6 7 1 6 3 4 5\n"
],
"output": [
"2\n1 2 4 3 \n",
"0\n4 5 6 3 2 1 \n",
"3\n2 8 4 6 7 1 9 3 10 5 \n"
]
} |
2,095 | 9 | Vasya the programmer lives in the middle of the Programming subway branch. He has two girlfriends: Dasha and Masha, who live at the different ends of the branch, each one is unaware of the other one's existence.
When Vasya has some free time, he goes to one of his girlfriends. He descends into the subway at some time, waits the first train to come and rides on it to the end of the branch to the corresponding girl. However, the trains run with different frequencies: a train goes to Dasha's direction every a minutes, but a train goes to Masha's direction every b minutes. If two trains approach at the same time, Vasya goes toward the direction with the lower frequency of going trains, that is, to the girl, to whose directions the trains go less frequently (see the note to the third sample).
We know that the trains begin to go simultaneously before Vasya appears. That is the train schedule is such that there exists a moment of time when the two trains arrive simultaneously.
Help Vasya count to which girlfriend he will go more often.
Input
The first line contains two integers a and b (a β b, 1 β€ a, b β€ 106).
Output
Print "Dasha" if Vasya will go to Dasha more frequently, "Masha" if he will go to Masha more frequently, or "Equal" if he will go to both girlfriends with the same frequency.
Examples
Input
3 7
Output
Dasha
Input
5 3
Output
Masha
Input
2 3
Output
Equal
Note
Let's take a look at the third sample. Let the trains start to go at the zero moment of time. It is clear that the moments of the trains' arrival will be periodic with period 6. That's why it is enough to show that if Vasya descends to the subway at a moment of time inside the interval (0, 6], he will go to both girls equally often.
If he descends to the subway at a moment of time from 0 to 2, he leaves for Dasha on the train that arrives by the second minute.
If he descends to the subway at a moment of time from 2 to 3, he leaves for Masha on the train that arrives by the third minute.
If he descends to the subway at a moment of time from 3 to 4, he leaves for Dasha on the train that arrives by the fourth minute.
If he descends to the subway at a moment of time from 4 to 6, he waits for both trains to arrive by the sixth minute and goes to Masha as trains go less often in Masha's direction.
In sum Masha and Dasha get equal time β three minutes for each one, thus, Vasya will go to both girlfriends equally often. | def GCD(a,b):
if b==0:
return a
else:
return GCD(b,a%b)
s = input()
a = int(s.split()[0])
b = int(s.split()[1])
g = GCD(a,b)
l = a*b//g
x = l//a
y = l//b
if x==y or abs(x-y)==1:
print('Equal')
elif x>y:
print('Dasha')
else:
print('Masha') | {
"input": [
"5 3\n",
"2 3\n",
"3 7\n"
],
"output": [
"Masha\n",
"Equal\n",
"Dasha\n"
]
} |
2,096 | 7 | The following problem is well-known: given integers n and m, calculate
<image>,
where 2n = 2Β·2Β·...Β·2 (n factors), and <image> denotes the remainder of division of x by y.
You are asked to solve the "reverse" problem. Given integers n and m, calculate
<image>.
Input
The first line contains a single integer n (1 β€ n β€ 108).
The second line contains a single integer m (1 β€ m β€ 108).
Output
Output a single integer β the value of <image>.
Examples
Input
4
42
Output
10
Input
1
58
Output
0
Input
98765432
23456789
Output
23456789
Note
In the first example, the remainder of division of 42 by 24 = 16 is equal to 10.
In the second example, 58 is divisible by 21 = 2 without remainder, and the answer is 0. | def main():
n=int(input())
m=int(input())
print(m if n >26 else m % (1<<n))
main() | {
"input": [
"98765432\n23456789\n",
"4\n42\n",
"1\n58\n"
],
"output": [
"23456789\n",
"10\n",
"0\n"
]
} |
2,097 | 7 | Fafa owns a company that works on huge projects. There are n employees in Fafa's company. Whenever the company has a new project to start working on, Fafa has to divide the tasks of this project among all the employees.
Fafa finds doing this every time is very tiring for him. So, he decided to choose the best l employees in his company as team leaders. Whenever there is a new project, Fafa will divide the tasks among only the team leaders and each team leader will be responsible of some positive number of employees to give them the tasks. To make this process fair for the team leaders, each one of them should be responsible for the same number of employees. Moreover, every employee, who is not a team leader, has to be under the responsibility of exactly one team leader, and no team leader is responsible for another team leader.
Given the number of employees n, find in how many ways Fafa could choose the number of team leaders l in such a way that it is possible to divide employees between them evenly.
Input
The input consists of a single line containing a positive integer n (2 β€ n β€ 105) β the number of employees in Fafa's company.
Output
Print a single integer representing the answer to the problem.
Examples
Input
2
Output
1
Input
10
Output
3
Note
In the second sample Fafa has 3 ways:
* choose only 1 employee as a team leader with 9 employees under his responsibility.
* choose 2 employees as team leaders with 4 employees under the responsibility of each of them.
* choose 5 employees as team leaders with 1 employee under the responsibility of each of them. | def la(n):
for x in range(1,n//2+1):
if not (n-x)%x:
yield x
print(len(list(la(int(input()))))) | {
"input": [
"10\n",
"2\n"
],
"output": [
"3",
"1"
]
} |
2,098 | 11 | You are given an integer n from 1 to 10^{18} without leading zeroes.
In one move you can swap any two adjacent digits in the given number in such a way that the resulting number will not contain leading zeroes. In other words, after each move the number you have cannot contain any leading zeroes.
What is the minimum number of moves you have to make to obtain a number that is divisible by 25? Print -1 if it is impossible to obtain a number that is divisible by 25.
Input
The first line contains an integer n (1 β€ n β€ 10^{18}). It is guaranteed that the first (left) digit of the number n is not a zero.
Output
If it is impossible to obtain a number that is divisible by 25, print -1. Otherwise print the minimum number of moves required to obtain such number.
Note that you can swap only adjacent digits in the given number.
Examples
Input
5071
Output
4
Input
705
Output
1
Input
1241367
Output
-1
Note
In the first example one of the possible sequences of moves is 5071 β 5701 β 7501 β 7510 β 7150. | s=input()[::-1]
t=len(s)
def g(c,i=0):return s.find(str(c),i)+1or 50
i,f=g(0),g(5)
j=min(g(0,i),f)
m=i+j+(j<i)
j=min(g(2),g(7))
l=f+j+(j<f)
if f==t:
while s[f-2]=='0':f-=1
l+=t-f
m=min(m,l)
print((-1,m-3)[m<40]) | {
"input": [
"705\n",
"1241367\n",
"5071\n"
],
"output": [
"1\n",
"-1\n",
"4\n"
]
} |
2,099 | 10 | Mitya has a rooted tree with n vertices indexed from 1 to n, where the root has index 1. Each vertex v initially had an integer number a_v β₯ 0 written on it. For every vertex v Mitya has computed s_v: the sum of all values written on the vertices on the path from vertex v to the root, as well as h_v β the depth of vertex v, which denotes the number of vertices on the path from vertex v to the root. Clearly, s_1=a_1 and h_1=1.
Then Mitya erased all numbers a_v, and by accident he also erased all values s_v for vertices with even depth (vertices with even h_v). Your task is to restore the values a_v for every vertex, or determine that Mitya made a mistake. In case there are multiple ways to restore the values, you're required to find one which minimizes the total sum of values a_v for all vertices in the tree.
Input
The first line contains one integer n β the number of vertices in the tree (2 β€ n β€ 10^5). The following line contains integers p_2, p_3, ... p_n, where p_i stands for the parent of vertex with index i in the tree (1 β€ p_i < i). The last line contains integer values s_1, s_2, ..., s_n (-1 β€ s_v β€ 10^9), where erased values are replaced by -1.
Output
Output one integer β the minimum total sum of all values a_v in the original tree, or -1 if such tree does not exist.
Examples
Input
5
1 1 1 1
1 -1 -1 -1 -1
Output
1
Input
5
1 2 3 1
1 -1 2 -1 -1
Output
2
Input
3
1 2
2 -1 1
Output
-1 | def f(s, p, n):
p = [0, 0] + p
s = [0] + s
for i in range(2, n + 1):
if s[i] != -1 and (s[p[i]] == -1 or (s[p[i]] > s[i])):
s[p[i]] = s[i]
a = [0] * (n + 1)
a[1]=s[1]
for i in range(2, n + 1):
if s[i] != -1:
c = s[i] - s[p[i]]
if c < 0:
return -1
a[i] = c
return sum(a)
n = int(input())
p = list(map(int, input().strip().split()))
s = list(map(int, input().strip().split()))
print(f(s, p, n)) | {
"input": [
"3\n1 2\n2 -1 1\n",
"5\n1 2 3 1\n1 -1 2 -1 -1\n",
"5\n1 1 1 1\n1 -1 -1 -1 -1\n"
],
"output": [
"-1\n",
"2\n",
"1\n"
]
} |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.