index
int64 0
5.16k
| difficulty
int64 7
12
| question
stringlengths 126
7.12k
| solution
stringlengths 30
18.6k
| test_cases
dict |
|---|---|---|---|---|
4,700 | 8 | You are standing on the OX-axis at point 0 and you want to move to an integer point x > 0.
You can make several jumps. Suppose you're currently at point y (y may be negative) and jump for the k-th time. You can:
* either jump to the point y + k
* or jump to the point y - 1.
What is the minimum number of jumps you need to reach the point x?
Input
The first line contains a single integer t (1 β€ t β€ 1000) β the number of test cases.
The first and only line of each test case contains the single integer x (1 β€ x β€ 10^6) β the destination point.
Output
For each test case, print the single integer β the minimum number of jumps to reach x. It can be proved that we can reach any integer point x.
Example
Input
5
1
2
3
4
5
Output
1
3
2
3
4
Note
In the first test case x = 1, so you need only one jump: the 1-st jump from 0 to 0 + 1 = 1.
In the second test case x = 2. You need at least three jumps:
* the 1-st jump from 0 to 0 + 1 = 1;
* the 2-nd jump from 1 to 1 + 2 = 3;
* the 3-rd jump from 3 to 3 - 1 = 2;
Two jumps are not enough because these are the only possible variants:
* the 1-st jump as -1 and the 2-nd one as -1 β you'll reach 0 -1 -1 =-2;
* the 1-st jump as -1 and the 2-nd one as +2 β you'll reach 0 -1 +2 = 1;
* the 1-st jump as +1 and the 2-nd one as -1 β you'll reach 0 +1 -1 = 0;
* the 1-st jump as +1 and the 2-nd one as +2 β you'll reach 0 +1 +2 = 3;
In the third test case, you need two jumps: the 1-st one as +1 and the 2-nd one as +2, so 0 + 1 + 2 = 3.
In the fourth test case, you need three jumps: the 1-st one as -1, the 2-nd one as +2 and the 3-rd one as +3, so 0 - 1 + 2 + 3 = 4. | def main():
x=int(input())
cur=0
cnt=0
while cur<x:
cnt+=1
cur+=cnt
print(cnt+1 if cur-1==x else cnt)
tt=int(input())
for _ in range(tt):
main()
| {
"input": [
"5\n1\n2\n3\n4\n5\n"
],
"output": [
"\n1\n3\n2\n3\n4\n"
]
} |
4,701 | 9 | Some time ago Homer lived in a beautiful city. There were n blocks numbered from 1 to n and m directed roads between them. Each road had a positive length, and each road went from the block with the smaller index to the block with the larger index. For every two (different) blocks, there was at most one road between them.
Homer discovered that for some two numbers L and R the city was (L, R)-continuous.
The city is said to be (L, R)-continuous, if
1. all paths from block 1 to block n are of length between L and R (inclusive); and
2. for every L β€ d β€ R, there is exactly one path from block 1 to block n whose length is d.
A path from block u to block v is a sequence u = x_0 β x_1 β x_2 β ... β x_k = v, where there is a road from block x_{i-1} to block x_{i} for every 1 β€ i β€ k. The length of a path is the sum of lengths over all roads in the path. Two paths x_0 β x_1 β ... β x_k and y_0 β y_1 β ... β y_l are different, if k β l or x_i β y_i for some 0 β€ i β€ min\\{k, l\}.
After moving to another city, Homer only remembers the two special numbers L and R but forgets the numbers n and m of blocks and roads, respectively, and how blocks are connected by roads. However, he believes the number of blocks should be no larger than 32 (because the city was small).
As the best friend of Homer, please tell him whether it is possible to find a (L, R)-continuous city or not.
Input
The single line contains two integers L and R (1 β€ L β€ R β€ 10^6).
Output
If it is impossible to find a (L, R)-continuous city within 32 blocks, print "NO" in a single line.
Otherwise, print "YES" in the first line followed by a description of a (L, R)-continuous city.
The second line should contain two integers n (2 β€ n β€ 32) and m (1 β€ m β€ \frac {n(n-1)} 2), where n denotes the number of blocks and m denotes the number of roads.
Then m lines follow. The i-th of the m lines should contain three integers a_i, b_i (1 β€ a_i < b_i β€ n) and c_i (1 β€ c_i β€ 10^6) indicating that there is a directed road from block a_i to block b_i of length c_i.
It is required that for every two blocks, there should be no more than 1 road connecting them. That is, for every 1 β€ i < j β€ m, either a_i β a_j or b_i β b_j.
Examples
Input
1 1
Output
YES
2 1
1 2 1
Input
4 6
Output
YES
5 6
1 2 3
1 3 4
1 4 5
2 5 1
3 5 1
4 5 1
Note
In the first example there is only one path from block 1 to block n = 2, and its length is 1.
In the second example there are three paths from block 1 to block n = 5, which are 1 β 2 β 5 of length 4, 1 β 3 β 5 of length 5 and 1 β 4 β 5 of length 6. | import sys, io, os
if os.environ['USERNAME']=='kissz':
inp=open('in2.txt','r').readline
def debug(*args):
print(*args,file=sys.stderr)
else:
inp=io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
def debug(*args):
pass
# SCRIPT STARTS HERE
def bits(x):
B=[]
while x:
B.append(x&1)
x>>=1
return B
L,R=map(int,inp().split())
N=R-L
roads=[]
B=bits(N)
n=len(B)+2
for i in range(2,n):
roads.append((1,i,1))
for j in range(2,i):
roads.append((j,i,2**(j-2)))
roads.append((1,n,L))
X=L
for i in range(2,n):
b=B[i-2]
if b:
roads.append((i,n,X))
X+=2**(i-2)
print('YES')
print(n,len(roads))
for road in roads:
print(*road)
| {
"input": [
"1 1\n",
"4 6\n"
],
"output": [
"\nYES\n2 1\n1 2 1\n",
"\nYES\n5 6\n1 2 3\n1 3 4\n1 4 5\n2 5 1\n3 5 1\n4 5 1\n"
]
} |
4,702 | 8 | You are given a number k and a string s of length n, consisting of the characters '.' and '*'. You want to replace some of the '*' characters with 'x' characters so that the following conditions are met:
* The first character '*' in the original string should be replaced with 'x';
* The last character '*' in the original string should be replaced with 'x';
* The distance between two neighboring replaced characters 'x' must not exceed k (more formally, if you replaced characters at positions i and j (i < j) and at positions [i+1, j-1] there is no "x" symbol, then j-i must be no more than k).
For example, if n=7, s=.**.*** and k=3, then the following strings will satisfy the conditions above:
* .xx.*xx;
* .x*.x*x;
* .xx.xxx.
But, for example, the following strings will not meet the conditions:
* .**.*xx (the first character '*' should be replaced with 'x');
* .x*.xx* (the last character '*' should be replaced with 'x');
* .x*.*xx (the distance between characters at positions 2 and 6 is greater than k=3).
Given n, k, and s, find the minimum number of '*' characters that must be replaced with 'x' in order to meet the above conditions.
Input
The first line contains one integer t (1 β€ t β€ 500). Then t test cases follow.
The first line of each test case contains two integers n and k (1 β€ k β€ n β€ 50).
The second line of each test case contains a string s of length n, consisting of the characters '.' and '*'.
It is guaranteed that there is at least one '*' in the string s.
It is guaranteed that the distance between any two neighboring '*' characters does not exceed k.
Output
For each test case output the minimum number of '*' characters that must be replaced with 'x' characters in order to satisfy the conditions above.
Example
Input
5
7 3
.**.***
5 1
..*..
5 2
*.*.*
3 2
*.*
1 1
*
Output
3
1
3
2
1 | def p(s,i,n,k):
if i==n-1:return 1
nxt=0
for j in range(k,0,-1):
if j+i<n:
if s[j+i]=='*':
nxt=j+i
break
return p(s,nxt,n,k)+1
for _ in range(int(input())):
n,k=map(int,input().split())
s=input().strip('.')
print(p(s,0,len(s),k)) | {
"input": [
"5\n7 3\n.**.***\n5 1\n..*..\n5 2\n*.*.*\n3 2\n*.*\n1 1\n*\n"
],
"output": [
"\n3\n1\n3\n2\n1\n"
]
} |
4,703 | 7 | Vasya, or Mr. Vasily Petrov is a dean of a department in a local university. After the winter exams he got his hands on a group's gradebook.
Overall the group has n students. They received marks for m subjects. Each student got a mark from 1 to 9 (inclusive) for each subject.
Let's consider a student the best at some subject, if there is no student who got a higher mark for this subject. Let's consider a student successful, if there exists a subject he is the best at.
Your task is to find the number of successful students in the group.
Input
The first input line contains two integers n and m (1 β€ n, m β€ 100) β the number of students and the number of subjects, correspondingly. Next n lines each containing m characters describe the gradebook. Each character in the gradebook is a number from 1 to 9. Note that the marks in a rows are not sepatated by spaces.
Output
Print the single number β the number of successful students in the given group.
Examples
Input
3 3
223
232
112
Output
2
Input
3 5
91728
11828
11111
Output
3
Note
In the first sample test the student number 1 is the best at subjects 1 and 3, student 2 is the best at subjects 1 and 2, but student 3 isn't the best at any subject.
In the second sample test each student is the best at at least one subject. | def readln(): return tuple(map(int, input().split()))
n, m = readln()
dis = list(zip(*tuple([list(input()) for _ in range(n)])))
best = [0]*n
for j in range(m):
t = max(dis[j])
for i in range(n):
if dis[j][i] == t:
best[i] = 1
print(sum(best))
| {
"input": [
"3 5\n91728\n11828\n11111\n",
"3 3\n223\n232\n112\n"
],
"output": [
"3\n",
"2\n"
]
} |
4,704 | 9 | You've got another problem dealing with arrays. Let's consider an arbitrary sequence containing n (not necessarily different) integers a1, a2, ..., an. We are interested in all possible pairs of numbers (ai, aj), (1 β€ i, j β€ n). In other words, let's consider all n2 pairs of numbers, picked from the given array.
For example, in sequence a = {3, 1, 5} are 9 pairs of numbers: (3, 3), (3, 1), (3, 5), (1, 3), (1, 1), (1, 5), (5, 3), (5, 1), (5, 5).
Let's sort all resulting pairs lexicographically by non-decreasing. Let us remind you that pair (p1, q1) is lexicographically less than pair (p2, q2) only if either p1 < p2, or p1 = p2 and q1 < q2.
Then the sequence, mentioned above, will be sorted like that: (1, 1), (1, 3), (1, 5), (3, 1), (3, 3), (3, 5), (5, 1), (5, 3), (5, 5)
Let's number all the pair in the sorted list from 1 to n2. Your task is formulated like this: you should find the k-th pair in the ordered list of all possible pairs of the array you've been given.
Input
The first line contains two integers n and k (1 β€ n β€ 105, 1 β€ k β€ n2). The second line contains the array containing n integers a1, a2, ..., an ( - 109 β€ ai β€ 109). The numbers in the array can coincide. All numbers are separated with spaces.
Please do not use the %lld specificator to read or write 64-bit integers in Π‘++. It is preferred to use cin, cout, streams or the %I64d specificator instead.
Output
In the single line print two numbers β the sought k-th pair.
Examples
Input
2 4
2 1
Output
2 2
Input
3 2
3 1 5
Output
1 3
Note
In the first sample the sorted sequence for the given array looks as: (1, 1), (1, 2), (2, 1), (2, 2). The 4-th of them is pair (2, 2).
The sorted sequence for the array from the second sample is given in the statement. The 2-nd pair there is (1, 3). | from collections import OrderedDict
def read_ints():
return map(int, input().split(' '))
n, k = read_ints()
a = list(read_ints())
a.sort()
l = (k - 1) // n
lo = l
while lo > 0 and a[lo - 1] == a[lo]:
lo -= 1
hi = l
while hi + 1 < n and a[hi + 1] == a[hi]:
hi += 1
length = hi - lo + 1
acc = k - lo * n
r = (acc - 1) // length
print(a[l], a[r])
| {
"input": [
"2 4\n2 1\n",
"3 2\n3 1 5\n"
],
"output": [
"2 2\n",
"1 3\n"
]
} |
4,705 | 7 | A boy Valera registered on site Codeforces as Valera, and wrote his first Codeforces Round #300. He boasted to a friend Arkady about winning as much as x points for his first contest. But Arkady did not believe his friend's words and decided to check whether Valera could have shown such a result.
He knows that the contest number 300 was unusual because there were only two problems. The contest lasted for t minutes, the minutes are numbered starting from zero. The first problem had the initial cost of a points, and every minute its cost reduced by da points. The second problem had the initial cost of b points, and every minute this cost reduced by db points. Thus, as soon as the zero minute of the contest is over, the first problem will cost a - da points, and the second problem will cost b - db points. It is guaranteed that at any moment of the contest each problem has a non-negative cost.
Arkady asks you to find out whether Valera could have got exactly x points for this contest. You should assume that Valera could have solved any number of the offered problems. You should also assume that for each problem Valera made no more than one attempt, besides, he could have submitted both problems at the same minute of the contest, starting with minute 0 and ending with minute number t - 1. Please note that Valera can't submit a solution exactly t minutes after the start of the contest or later.
Input
The single line of the input contains six integers x, t, a, b, da, db (0 β€ x β€ 600; 1 β€ t, a, b, da, db β€ 300) β Valera's result, the contest's duration, the initial cost of the first problem, the initial cost of the second problem, the number of points that the first and the second problem lose per minute, correspondingly.
It is guaranteed that at each minute of the contest each problem has a non-negative cost, that is, a - iΒ·da β₯ 0 and b - iΒ·db β₯ 0 for all 0 β€ i β€ t - 1.
Output
If Valera could have earned exactly x points at a contest, print "YES", otherwise print "NO" (without the quotes).
Examples
Input
30 5 20 20 3 5
Output
YES
Input
10 4 100 5 5 1
Output
NO
Note
In the first sample Valera could have acted like this: he could have submitted the first problem at minute 0 and the second problem β at minute 2. Then the first problem brings him 20 points and the second problem brings him 10 points, that in total gives the required 30 points. | def solve():
x, t, a, b, da, db = map(int, input().split())
if x == 0:
print("YES")
return
for i in range(t):
f = a-i*da
if f == x:
print("YES")
return
for j in range(t):
g = b-j*db
if g == x or f+g == x:
print("YES")
return
print("NO")
solve()
| {
"input": [
"10 4 100 5 5 1\n",
"30 5 20 20 3 5\n"
],
"output": [
"NO\n",
"YES\n"
]
} |
4,706 | 10 | A little girl loves problems on bitwise operations very much. Here's one of them.
You are given two integers l and r. Let's consider the values of <image> for all pairs of integers a and b (l β€ a β€ b β€ r). Your task is to find the maximum value among all considered ones.
Expression <image> means applying bitwise excluding or operation to integers x and y. The given operation exists in all modern programming languages, for example, in languages C++ and Java it is represented as "^", in Pascal β as "xor".
Input
The single line contains space-separated integers l and r (1 β€ l β€ r β€ 1018).
Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier.
Output
In a single line print a single integer β the maximum value of <image> for all pairs of integers a, b (l β€ a β€ b β€ r).
Examples
Input
1 2
Output
3
Input
8 16
Output
31
Input
1 1
Output
0 | def solve():
l, r = map(int, input().split())
if l==r:
print(0)
return
mx = str(bin(l^r))
x = len(mx[2:])
print(2**x-1)
solve() | {
"input": [
"8 16\n",
"1 2\n",
"1 1\n"
],
"output": [
"31\n",
"3\n",
"0\n"
]
} |
4,707 | 7 | In a Berland's zoo there is an enclosure with camels. It is known that camels like to spit. Bob watched these interesting animals for the whole day and registered in his notepad where each animal spitted. Now he wants to know if in the zoo there are two camels, which spitted at each other. Help him to solve this task.
The trajectory of a camel's spit is an arc, i.e. if the camel in position x spits d meters right, he can hit only the camel in position x + d, if such a camel exists.
Input
The first line contains integer n (1 β€ n β€ 100) β the amount of camels in the zoo. Each of the following n lines contains two integers xi and di ( - 104 β€ xi β€ 104, 1 β€ |di| β€ 2Β·104) β records in Bob's notepad. xi is a position of the i-th camel, and di is a distance at which the i-th camel spitted. Positive values of di correspond to the spits right, negative values correspond to the spits left. No two camels may stand in the same position.
Output
If there are two camels, which spitted at each other, output YES. Otherwise, output NO.
Examples
Input
2
0 1
1 -1
Output
YES
Input
3
0 1
1 1
2 -2
Output
NO
Input
5
2 -10
3 10
0 5
5 -5
10 1
Output
YES | def main():
n = int(input())
c = [tuple(map(int,input().split())) for i in range(n)]
pairs = [(a,b) for a in c for b in c]
for (a,b) in pairs:
if a[0] + a[1] == b[0] and b[0] + b[1] == a[0]:
return 'YES'
return 'NO'
print(main())
| {
"input": [
"5\n2 -10\n3 10\n0 5\n5 -5\n10 1\n",
"3\n0 1\n1 1\n2 -2\n",
"2\n0 1\n1 -1\n"
],
"output": [
"YES\n",
"NO\n",
"YES\n"
]
} |
4,708 | 10 | Fox Ciel is playing a card game with her friend Jiro.
Jiro has n cards, each one has two attributes: position (Attack or Defense) and strength. Fox Ciel has m cards, each one has these two attributes too. It's known that position of all Ciel's cards is Attack.
Now is Ciel's battle phase, Ciel can do the following operation many times:
1. Choose one of her cards X. This card mustn't be chosen before.
2. If Jiro has no alive cards at that moment, he gets the damage equal to (X's strength). Otherwise, Ciel needs to choose one Jiro's alive card Y, then:
* If Y's position is Attack, then (X's strength) β₯ (Y's strength) must hold. After this attack, card Y dies, and Jiro gets the damage equal to (X's strength) - (Y's strength).
* If Y's position is Defense, then (X's strength) > (Y's strength) must hold. After this attack, card Y dies, but Jiro gets no damage.
Ciel can end her battle phase at any moment (so, she can use not all her cards). Help the Fox to calculate the maximal sum of damage Jiro can get.
Input
The first line contains two integers n and m (1 β€ n, m β€ 100) β the number of cards Jiro and Ciel have.
Each of the next n lines contains a string position and an integer strength (0 β€ strength β€ 8000) β the position and strength of Jiro's current card. Position is the string "ATK" for attack, and the string "DEF" for defense.
Each of the next m lines contains an integer strength (0 β€ strength β€ 8000) β the strength of Ciel's current card.
Output
Output an integer: the maximal damage Jiro can get.
Examples
Input
2 3
ATK 2000
DEF 1700
2500
2500
2500
Output
3000
Input
3 4
ATK 10
ATK 100
ATK 1000
1
11
101
1001
Output
992
Input
2 4
DEF 0
ATK 0
0
0
1
1
Output
1
Note
In the first test case, Ciel has 3 cards with same strength. The best strategy is as follows. First she uses one of these 3 cards to attack "ATK 2000" card first, this attack destroys that card and Jiro gets 2500 - 2000 = 500 damage. Then she uses the second card to destroy the "DEF 1700" card. Jiro doesn't get damage that time. Now Jiro has no cards so she can use the third card to attack and Jiro gets 2500 damage. So the answer is 500 + 2500 = 3000.
In the second test case, she should use the "1001" card to attack the "ATK 100" card, then use the "101" card to attack the "ATK 10" card. Now Ciel still has cards but she can choose to end her battle phase. The total damage equals (1001 - 100) + (101 - 10) = 992.
In the third test case note that she can destroy the "ATK 0" card by a card with strength equal to 0, but she can't destroy a "DEF 0" card with that card. | n, m = map(int, input().split())
(a, d) = ([], [])
for i in range(n):
t, val = input().split()
(a if t == 'ATK' else d).append(int(val))
my = sorted([int(input()) for i in range(m)])
a.sort()
d.sort()
def solve1():
ret = 0
used = [False] * m
for val in d:
for i in range(m):
if not used[i] and my[i] > val:
used[i] = True
break
else:
return 0
for val in a:
for i in range(m):
if not used[i] and my[i] >= val:
used[i] = True
ret += my[i] - val
break
else:
return 0
return ret + sum([my[i] for i in range(m) if not used[i]])
def solve2():
ret = 0
for k in range(min(len(a), m)):
if my[-k-1] >= a[k]: ret += my[-k-1] - a[k]
else: break
return ret
print(max(solve1(), solve2())) | {
"input": [
"2 4\nDEF 0\nATK 0\n0\n0\n1\n1\n",
"2 3\nATK 2000\nDEF 1700\n2500\n2500\n2500\n",
"3 4\nATK 10\nATK 100\nATK 1000\n1\n11\n101\n1001\n"
],
"output": [
"1\n",
"3000\n",
"992\n"
]
} |
4,709 | 8 | A permutation of length n is an integer sequence such that each integer from 0 to (n - 1) appears exactly once in it. For example, sequence [0, 2, 1] is a permutation of length 3 while both [0, 2, 2] and [1, 2, 3] are not.
A fixed point of a function is a point that is mapped to itself by the function. A permutation can be regarded as a bijective function. We'll get a definition of a fixed point in a permutation. An integer i is a fixed point of permutation a0, a1, ..., an - 1 if and only if ai = i. For example, permutation [0, 2, 1] has 1 fixed point and permutation [0, 1, 2] has 3 fixed points.
You are given permutation a. You are allowed to swap two elements of the permutation at most once. Your task is to maximize the number of fixed points in the resulting permutation. Note that you are allowed to make at most one swap operation.
Input
The first line contains a single integer n (1 β€ n β€ 105). The second line contains n integers a0, a1, ..., an - 1 β the given permutation.
Output
Print a single integer β the maximum possible number of fixed points in the permutation after at most one swap operation.
Examples
Input
5
0 1 3 4 2
Output
3 | def f(l):
n = len(l)
c = sum([i==l[i] for i in range(n)])
if c==n:
return c
d = sum([l[l[i]]==i for i in range(n) if i!=l[i]])
return c+2 if d>0 else c+1
q = int(input())
l = list(map(int,input().split()))
print(f(l))
| {
"input": [
"5\n0 1 3 4 2\n"
],
"output": [
"3\n"
]
} |
4,710 | 9 | A Christmas party in city S. had n children. All children came in mittens. The mittens can be of different colors, but each child had the left and the right mitten of the same color. Let's say that the colors of the mittens are numbered with integers from 1 to m, and the children are numbered from 1 to n. Then the i-th child has both mittens of color ci.
The Party had Santa Claus ('Father Frost' in Russian), his granddaughter Snow Girl, the children danced around the richly decorated Christmas tree. In fact, everything was so bright and diverse that the children wanted to wear mittens of distinct colors. The children decided to swap the mittens so that each of them got one left and one right mitten in the end, and these two mittens were of distinct colors. All mittens are of the same size and fit all the children.
The children started exchanging the mittens haphazardly, but they couldn't reach the situation when each child has a pair of mittens of distinct colors. Vasily Petrov, the dad of one of the children, noted that in the general case the children's idea may turn out impossible. Besides, he is a mathematician and he came up with such scheme of distributing mittens that the number of children that have distinct-colored mittens was maximum. You task is to repeat his discovery. Note that the left and right mittens are different: each child must end up with one left and one right mitten.
Input
The first line contains two integers n and m β the number of the children and the number of possible mitten colors (1 β€ n β€ 5000, 1 β€ m β€ 100). The second line contains n integers c1, c2, ... cn, where ci is the color of the mittens of the i-th child (1 β€ ci β€ m).
Output
In the first line, print the maximum number of children who can end up with a distinct-colored pair of mittens. In the next n lines print the way the mittens can be distributed in this case. On the i-th of these lines print two space-separated integers: the color of the left and the color of the right mitten the i-th child will get. If there are multiple solutions, you can print any of them.
Examples
Input
6 3
1 3 2 2 1 1
Output
6
2 1
1 2
2 1
1 3
1 2
3 1
Input
4 2
1 2 1 1
Output
2
1 2
1 1
2 1
1 1 | from collections import Counter
def main():
n, m = map(int, input().split())
c = list(map(int, input().split()))
sc = sorted(range(n), key=lambda x: c[x])
mc = Counter(c).most_common(1)[0][1]
print(n if mc <= n - mc else 2*(n - mc))
for i in range(n):
print(c[sc[i]], c[sc[i-mc]])
if __name__ == '__main__':
main()
| {
"input": [
"4 2\n1 2 1 1\n",
"6 3\n1 3 2 2 1 1\n"
],
"output": [
"2\n1 2\n1 1\n1 1\n2 1\n",
"6\n1 2\n1 2\n1 3\n2 1\n2 1\n3 1\n"
]
} |
4,711 | 7 | Mashmokh works in a factory. At the end of each day he must turn off all of the lights.
The lights on the factory are indexed from 1 to n. There are n buttons in Mashmokh's room indexed from 1 to n as well. If Mashmokh pushes button with index i, then each light with index not less than i that is still turned on turns off.
Mashmokh is not very clever. So instead of pushing the first button he pushes some of the buttons randomly each night. He pushed m distinct buttons b1, b2, ..., bm (the buttons were pushed consecutively in the given order) this night. Now he wants to know for each light the index of the button that turned this light off. Please note that the index of button bi is actually bi, not i.
Please, help Mashmokh, print these indices.
Input
The first line of the input contains two space-separated integers n and m (1 β€ n, m β€ 100), the number of the factory lights and the pushed buttons respectively. The next line contains m distinct space-separated integers b1, b2, ..., bm (1 β€ bi β€ n).
It is guaranteed that all lights will be turned off after pushing all buttons.
Output
Output n space-separated integers where the i-th number is index of the button that turns the i-th light off.
Examples
Input
5 4
4 3 1 2
Output
1 1 3 4 4
Input
5 5
5 4 3 2 1
Output
1 2 3 4 5
Note
In the first sample, after pressing button number 4, lights 4 and 5 are turned off and lights 1, 2 and 3 are still on. Then after pressing button number 3, light number 3 is turned off as well. Pressing button number 1 turns off lights number 1 and 2 as well so pressing button number 2 in the end has no effect. Thus button number 4 turned lights 4 and 5 off, button number 3 turned light 3 off and button number 1 turned light 1 and 2 off. | def cal(a,i,n):
for j in range(i-1,n):
if a[j]==-1:
a[j]=i
n,m=map(int,input().split())
l = [*map(int,input().split())]
a = [-1]*n
for i in l:
cal(a,i,n)
print(*a) | {
"input": [
"5 5\n5 4 3 2 1\n",
"5 4\n4 3 1 2\n"
],
"output": [
"1 2 3 4 5\n",
"1 1 3 4 4\n"
]
} |
4,712 | 9 | Fox Ciel is going to publish a paper on FOCS (Foxes Operated Computer Systems, pronounce: "Fox"). She heard a rumor: the authors list on the paper is always sorted in the lexicographical order.
After checking some examples, she found out that sometimes it wasn't true. On some papers authors' names weren't sorted in lexicographical order in normal sense. But it was always true that after some modification of the order of letters in alphabet, the order of authors becomes lexicographical!
She wants to know, if there exists an order of letters in Latin alphabet such that the names on the paper she is submitting are following in the lexicographical order. If so, you should find out any such order.
Lexicographical order is defined in following way. When we compare s and t, first we find the leftmost position with differing characters: si β ti. If there is no such position (i. e. s is a prefix of t or vice versa) the shortest string is less. Otherwise, we compare characters si and ti according to their order in alphabet.
Input
The first line contains an integer n (1 β€ n β€ 100): number of names.
Each of the following n lines contain one string namei (1 β€ |namei| β€ 100), the i-th name. Each name contains only lowercase Latin letters. All names are different.
Output
If there exists such order of letters that the given names are sorted lexicographically, output any such order as a permutation of characters 'a'β'z' (i. e. first output the first letter of the modified alphabet, then the second, and so on).
Otherwise output a single word "Impossible" (without quotes).
Examples
Input
3
rivest
shamir
adleman
Output
bcdefghijklmnopqrsatuvwxyz
Input
10
tourist
petr
wjmzbmr
yeputons
vepifanov
scottwu
oooooooooooooooo
subscriber
rowdark
tankengineer
Output
Impossible
Input
10
petr
egor
endagorion
feferivan
ilovetanyaromanova
kostka
dmitriyh
maratsnowbear
bredorjaguarturnik
cgyforever
Output
aghjlnopefikdmbcqrstuvwxyz
Input
7
car
care
careful
carefully
becarefuldontforgetsomething
otherwiseyouwillbehacked
goodluck
Output
acbdefhijklmnogpqrstuvwxyz | n=int(input())
g=[set() for _ in range(26)]
t=[0]*26
a=input()
for _ in range(1,n):
b=input()
j=0
while j<min(len(a),len(b)) and a[j]==b[j]:j+=1
if j<min(len(a),len(b)) and a[j]!=b[j]:g[ord(a[j])-ord('a')].add(ord(b[j])-ord('a'))
elif len(a)>len(b):print('Impossible');exit()
a=b
o=[]
def dfs(x):
t[x]=1
for j in g[x]:
if t[j]==1:print('Impossible');exit()
if t[j]==0:dfs(j)
t[x]=2
o.append(chr(x+ord('a')))
for i in range(26):
if t[i]==0:
dfs(i)
print(''.join(reversed(o))) | {
"input": [
"7\ncar\ncare\ncareful\ncarefully\nbecarefuldontforgetsomething\notherwiseyouwillbehacked\ngoodluck\n",
"3\nrivest\nshamir\nadleman\n",
"10\npetr\negor\nendagorion\nfeferivan\nilovetanyaromanova\nkostka\ndmitriyh\nmaratsnowbear\nbredorjaguarturnik\ncgyforever\n",
"10\ntourist\npetr\nwjmzbmr\nyeputons\nvepifanov\nscottwu\noooooooooooooooo\nsubscriber\nrowdark\ntankengineer\n"
],
"output": [
"zyxwvutsrqpnmlkjihfedcboga",
"zyxwvutrsqponmlkjihgfedcba",
"zyxwvutsrqpoljhgnefikdmbca",
"Impossible"
]
} |
4,713 | 10 | Tavas is a strange creature. Usually "zzz" comes out of people's mouth while sleeping, but string s of length n comes out from Tavas' mouth instead.
<image>
Today Tavas fell asleep in Malekas' place. While he was sleeping, Malekas did a little process on s. Malekas has a favorite string p. He determined all positions x1 < x2 < ... < xk where p matches s. More formally, for each xi (1 β€ i β€ k) he condition sxisxi + 1... sxi + |p| - 1 = p is fullfilled.
Then Malekas wrote down one of subsequences of x1, x2, ... xk (possibly, he didn't write anything) on a piece of paper. Here a sequence b is a subsequence of sequence a if and only if we can turn a into b by removing some of its elements (maybe no one of them or all).
After Tavas woke up, Malekas told him everything. He couldn't remember string s, but he knew that both p and s only contains lowercase English letters and also he had the subsequence he had written on that piece of paper.
Tavas wonders, what is the number of possible values of s? He asked SaDDas, but he wasn't smart enough to solve this. So, Tavas asked you to calculate this number for him.
Answer can be very large, so Tavas wants you to print the answer modulo 109 + 7.
Input
The first line contains two integers n and m, the length of s and the length of the subsequence Malekas wrote down (1 β€ n β€ 106 and 0 β€ m β€ n - |p| + 1).
The second line contains string p (1 β€ |p| β€ n).
The next line contains m space separated integers y1, y2, ..., ym, Malekas' subsequence (1 β€ y1 < y2 < ... < ym β€ n - |p| + 1).
Output
In a single line print the answer modulo 1000 000 007.
Examples
Input
6 2
ioi
1 3
Output
26
Input
5 2
ioi
1 2
Output
0
Note
In the first sample test all strings of form "ioioi?" where the question mark replaces arbitrary English letter satisfy.
Here |x| denotes the length of string x.
Please note that it's possible that there is no such string (answer is 0). | import sys
def prefix(s):
m = len(s)
v = [0]*len(s)
for i in range(1,len(s)):
k = v[i-1]
while k > 0 and s[k] != s[i]:
k = v[k-1]
if s[k] == s[i]:
k = k + 1
v[i] = k
w = set()
i = m-1
while v[i] != 0:
w.add(m-v[i])
i = v[i]-1
return w
n,m = map(int, input().split())
if m == 0:
print(pow(26, n, 1000000007))
sys.exit(0)
p = input()
l = len(p)
x = list(map(int,input().split()))
w = prefix(p)
busy = l
for i in range(1,m):
if x[i]-x[i-1] < l and (x[i] - x[i-1]) not in w:
print(0)
sys.exit(0)
busy += min(x[i]-x[i-1], l)
print(pow(26,n-busy, 1000000007))
| {
"input": [
"5 2\nioi\n1 2\n",
"6 2\nioi\n1 3\n"
],
"output": [
"0\n",
"26\n"
]
} |
4,714 | 8 | A little boy Laurenty has been playing his favourite game Nota for quite a while and is now very hungry. The boy wants to make sausage and cheese sandwiches, but first, he needs to buy a sausage and some cheese.
The town where Laurenty lives in is not large. The houses in it are located in two rows, n houses in each row. Laurenty lives in the very last house of the second row. The only shop in town is placed in the first house of the first row.
The first and second rows are separated with the main avenue of the city. The adjacent houses of one row are separated by streets.
Each crosswalk of a street or an avenue has some traffic lights. In order to cross the street, you need to press a button on the traffic light, wait for a while for the green light and cross the street. Different traffic lights can have different waiting time.
The traffic light on the crosswalk from the j-th house of the i-th row to the (j + 1)-th house of the same row has waiting time equal to aij (1 β€ i β€ 2, 1 β€ j β€ n - 1). For the traffic light on the crossing from the j-th house of one row to the j-th house of another row the waiting time equals bj (1 β€ j β€ n). The city doesn't have any other crossings.
The boy wants to get to the store, buy the products and go back. The main avenue of the city is wide enough, so the boy wants to cross it exactly once on the way to the store and exactly once on the way back home. The boy would get bored if he had to walk the same way again, so he wants the way home to be different from the way to the store in at least one crossing.
<image> Figure to the first sample.
Help Laurenty determine the minimum total time he needs to wait at the crossroads.
Input
The first line of the input contains integer n (2 β€ n β€ 50) β the number of houses in each row.
Each of the next two lines contains n - 1 space-separated integer β values aij (1 β€ aij β€ 100).
The last line contains n space-separated integers bj (1 β€ bj β€ 100).
Output
Print a single integer β the least total time Laurenty needs to wait at the crossroads, given that he crosses the avenue only once both on his way to the store and on his way back home.
Examples
Input
4
1 2 3
3 2 1
3 2 2 3
Output
12
Input
3
1 2
3 3
2 1 3
Output
11
Input
2
1
1
1 1
Output
4
Note
The first sample is shown on the figure above.
In the second sample, Laurenty's path can look as follows:
* Laurenty crosses the avenue, the waiting time is 3;
* Laurenty uses the second crossing in the first row, the waiting time is 2;
* Laurenty uses the first crossing in the first row, the waiting time is 1;
* Laurenty uses the first crossing in the first row, the waiting time is 1;
* Laurenty crosses the avenue, the waiting time is 1;
* Laurenty uses the second crossing in the second row, the waiting time is 3.
In total we get that the answer equals 11.
In the last sample Laurenty visits all the crossings, so the answer is 4. | n=int(input())-1
def d():
return list(map(int,input().split()))
a=d()
b=d()
c=d()
v=[]
while n>=0:
v.append(sum(a[:n])+c[n]+sum(b[n:]))
n-=1
v.sort()
print(v[0]+v[1]) | {
"input": [
"2\n1\n1\n1 1\n",
"3\n1 2\n3 3\n2 1 3\n",
"4\n1 2 3\n3 2 1\n3 2 2 3\n"
],
"output": [
"4\n",
"11\n",
"12\n"
]
} |
4,715 | 9 | There are n beacons located at distinct positions on a number line. The i-th beacon has position ai and power level bi. When the i-th beacon is activated, it destroys all beacons to its left (direction of decreasing coordinates) within distance bi inclusive. The beacon itself is not destroyed however. Saitama will activate the beacons one at a time from right to left. If a beacon is destroyed, it cannot be activated.
Saitama wants Genos to add a beacon strictly to the right of all the existing beacons, with any position and any power level, such that the least possible number of beacons are destroyed. Note that Genos's placement of the beacon means it will be the first beacon activated. Help Genos by finding the minimum number of beacons that could be destroyed.
Input
The first line of input contains a single integer n (1 β€ n β€ 100 000) β the initial number of beacons.
The i-th of next n lines contains two integers ai and bi (0 β€ ai β€ 1 000 000, 1 β€ bi β€ 1 000 000) β the position and power level of the i-th beacon respectively. No two beacons will have the same position, so ai β aj if i β j.
Output
Print a single integer β the minimum number of beacons that could be destroyed if exactly one beacon is added.
Examples
Input
4
1 9
3 1
6 1
7 4
Output
1
Input
7
1 1
2 1
3 1
4 1
5 1
6 1
7 1
Output
3
Note
For the first sample case, the minimum number of beacons destroyed is 1. One way to achieve this is to place a beacon at position 9 with power level 2.
For the second sample case, the minimum number of beacons destroyed is 3. One way to achieve this is to place a beacon at position 1337 with power level 42. | def main():
n = int(input())
bb = [0] * 1000001
for _ in range(n):
a, b = map(int, input().split())
bb[a] = b
a = 0
for i, b in enumerate(bb):
if b:
a = (bb[i - b - 1] + 1) if i > b else 1
bb[i] = a
print(n - max(bb))
if __name__ == '__main__':
main()
| {
"input": [
"7\n1 1\n2 1\n3 1\n4 1\n5 1\n6 1\n7 1\n",
"4\n1 9\n3 1\n6 1\n7 4\n"
],
"output": [
"3\n",
"1\n"
]
} |
4,716 | 8 | Tyndex is again well ahead of the rivals! The reaction to the release of Zoozle Chrome browser was the release of a new browser Tyndex.Brome!
The popularity of the new browser is growing daily. And the secret is not even the Tyndex.Bar installed (the Tyndex.Bar automatically fills the glass with the finest 1664 cognac after you buy Tyndex.Bottles and insert in into a USB port). It is highly popular due to the well-thought interaction with the user.
Let us take, for example, the system of automatic address correction. Have you entered codehorses instead of codeforces? The gloomy Zoozle Chrome will sadly say that the address does not exist. Tyndex.Brome at the same time will automatically find the closest address and sent you there. That's brilliant!
How does this splendid function work? That's simple! For each potential address a function of the F error is calculated by the following rules:
* for every letter ci from the potential address c the closest position j of the letter ci in the address (s) entered by the user is found. The absolute difference |i - j| of these positions is added to F. So for every i (1 β€ i β€ |c|) the position j is chosen such, that ci = sj, and |i - j| is minimal possible.
* if no such letter ci exists in the address entered by the user, then the length of the potential address |c| is added to F.
After the values of the error function have been calculated for all the potential addresses the most suitable one is found.
To understand the special features of the above described method better, it is recommended to realize the algorithm of calculating the F function for an address given by the user and some set of potential addresses. Good luck!
Input
The first line contains two integers n and k (1 β€ n β€ 105, 1 β€ k β€ 105). They are the number of potential addresses and the length of the address entered by the user. The next line contains k lowercase Latin letters. They are the address entered by the user (s). Each next i-th (1 β€ i β€ n) line contains a non-empty sequence of lowercase Latin letters. They are the potential address. It is guaranteed that the total length of all the lines does not exceed 2Β·105.
Output
On each n line of the output file print a single number: the value of the error function when the current potential address is chosen.
Please, do not use %lld specificator to read or write 64-bit integers in C++. It is preffered to use cout (also you may use %I64d).
Examples
Input
2 10
codeforces
codeforces
codehorses
Output
0
12
Input
9 9
vkontakte
vcontacte
vkontrakte
vkollapse
vkrokodile
vtopke
vkapuste
vpechke
vk
vcodeforcese
Output
18
14
36
47
14
29
30
0
84 | from bisect import bisect_left
n, k = map(int, input().split())
q = 'abcdefghijklmnopqrstuvwxyz'
a = {i: [] for i in q}
for i, j in enumerate(input()): a[j].append(i)
def g(t): return [(t[i] + t[i - 1]) // 2 for i in range(1, len(t))]
c = {i: g(a[i]) for i in q}
def f():
global a, c
s, t = 0, input()
d = len(t)
for i, j in enumerate(t):
if a[j]:
if c[j]: s += abs(i - a[j][bisect_left(c[j], i)])
else: s += abs(i - a[j][0])
else: s += d
return str(s)
print('\n'.join(f() for i in range(n))) | {
"input": [
"9 9\nvkontakte\nvcontacte\nvkontrakte\nvkollapse\nvkrokodile\nvtopke\nvkapuste\nvpechke\nvk\nvcodeforcese\n",
"2 10\ncodeforces\ncodeforces\ncodehorses\n"
],
"output": [
"18\n14\n36\n47\n14\n29\n30\n0\n84\n",
"0\n12\n"
]
} |
4,717 | 7 |
Input
The input contains a single integer a (0 β€ a β€ 35).
Output
Output a single integer.
Examples
Input
3
Output
8
Input
10
Output
1024 | def main():
A = int(input())
print(A % 2)
main()
| {
"input": [
"10\n",
"3\n"
],
"output": [
"0\n",
"1\n"
]
} |
4,718 | 7 | A teacher decides to give toffees to his students. He asks n students to stand in a queue. Since the teacher is very partial, he follows the following rule to distribute toffees.
He looks at the first two students and gives more toffees to the student having higher marks than the other one. If they have the same marks they get the same number of toffees. The same procedure is followed for each pair of adjacent students starting from the first one to the last one.
It is given that each student receives at least one toffee. You have to find the number of toffees given to each student by the teacher such that the total number of toffees is minimum.
Input
The first line of input contains the number of students n (2 β€ n β€ 1000). The second line gives (n - 1) characters consisting of "L", "R" and "=". For each pair of adjacent students "L" means that the left student has higher marks, "R" means that the right student has higher marks and "=" means that both have equal marks.
Output
Output consists of n integers separated by a space representing the number of toffees each student receives in the queue starting from the first one to the last one.
Examples
Input
5
LRLR
Output
2 1 2 1 2
Input
5
=RRR
Output
1 1 2 3 4 | import copy
n = int(input())
difference = input()
answer = [0 for i in range(n)]
def is_local_min(i, difference):
for j in range(i - 1, -1, -1):
if difference[j] == 'R':
return False
if difference[j] == 'L':
break
for j in difference[i:]:
if j == 'L':
return False
if j == 'R':
break
return True
loc_min_lst = []
for i in range(n):
if is_local_min(i, difference):
loc_min_lst.append(i)
value = 0
for i in loc_min_lst:
value = 1
for j in range(i, -1, -1):
if j == 0:
answer[0] = value
value = 1
break
if answer[j] >= value:
break
else:
answer[j] = value
if difference[j - 1] == 'R':
break
if difference[j - 1] == 'L':
value += 1
value = 1
for j in range(i, n):
if j == n - 1:
answer[n - 1] = value
value = 1
break
if answer[j] > value:
break
else:
answer[j] = value
if difference[j] == 'L':
break
if difference[j] == 'R':
value += 1
print(' '.join([str(x) for x in answer]))
| {
"input": [
"5\nLRLR\n",
"5\n=RRR\n"
],
"output": [
"2 1 2 1 2 \n",
"1 1 2 3 4 \n"
]
} |
4,719 | 7 | You are given array consisting of n integers. Your task is to find the maximum length of an increasing subarray of the given array.
A subarray is the sequence of consecutive elements of the array. Subarray is called increasing if each element of this subarray strictly greater than previous.
Input
The first line contains single positive integer n (1 β€ n β€ 105) β the number of integers.
The second line contains n positive integers a1, a2, ..., an (1 β€ ai β€ 109).
Output
Print the maximum length of an increasing subarray of the given array.
Examples
Input
5
1 7 2 11 15
Output
3
Input
6
100 100 100 100 100 100
Output
1
Input
3
1 2 3
Output
3 | def lis(a):
n = len(a)
F = [1] * n
for i in range(1, n):
if a[i - 1] < a[i]:
F[i] += F[i - 1]
return max(F)
n = int(input())
a = tuple(map(int, input().split()))
print(lis(a)) | {
"input": [
"5\n1 7 2 11 15\n",
"6\n100 100 100 100 100 100\n",
"3\n1 2 3\n"
],
"output": [
"3\n",
"1\n",
"3\n"
]
} |
4,720 | 8 | You are given a table consisting of n rows and m columns.
Numbers in each row form a permutation of integers from 1 to m.
You are allowed to pick two elements in one row and swap them, but no more than once for each row. Also, no more than once you are allowed to pick two columns and swap them. Thus, you are allowed to perform from 0 to n + 1 actions in total. Operations can be performed in any order.
You have to check whether it's possible to obtain the identity permutation 1, 2, ..., m in each row. In other words, check if one can perform some of the operation following the given rules and make each row sorted in increasing order.
Input
The first line of the input contains two integers n and m (1 β€ n, m β€ 20) β the number of rows and the number of columns in the given table.
Each of next n lines contains m integers β elements of the table. It's guaranteed that numbers in each line form a permutation of integers from 1 to m.
Output
If there is a way to obtain the identity permutation in each row by following the given rules, print "YES" (without quotes) in the only line of the output. Otherwise, print "NO" (without quotes).
Examples
Input
2 4
1 3 2 4
1 3 4 2
Output
YES
Input
4 4
1 2 3 4
2 3 4 1
3 4 1 2
4 1 2 3
Output
NO
Input
3 6
2 1 3 4 5 6
1 2 4 3 5 6
1 2 3 4 6 5
Output
YES
Note
In the first sample, one can act in the following way:
1. Swap second and third columns. Now the table is 1 2 3 4 1 4 3 2
2. In the second row, swap the second and the fourth elements. Now the table is 1 2 3 4 1 2 3 4 | def get_perms(perm):
perms = {tuple(perm)}
for i in range(len(perm)):
for j in range(i+1, len(perm)):
perm_copy = list(perm)
perm_copy[i], perm_copy[j] = perm_copy[j], perm_copy[i]
perms.add(tuple(perm_copy))
return perms
n, m = map(int, input().split(' '))
good_perms = get_perms([i for i in range(1, m+1)])
for i in range(n):
perm = list(map(int, input().split(' ')))
good_perms &= get_perms(perm)
if good_perms:
print('YES')
else:
print('NO')
| {
"input": [
"2 4\n1 3 2 4\n1 3 4 2\n",
"4 4\n1 2 3 4\n2 3 4 1\n3 4 1 2\n4 1 2 3\n",
"3 6\n2 1 3 4 5 6\n1 2 4 3 5 6\n1 2 3 4 6 5\n"
],
"output": [
"YES",
"NO",
"YES"
]
} |
4,721 | 8 | Polycarp is mad about coding, that is why he writes Sveta encoded messages. He calls the median letter in a word the letter which is in the middle of the word. If the word's length is even, the median letter is the left of the two middle letters. In the following examples, the median letter is highlighted: contest, info. If the word consists of single letter, then according to above definition this letter is the median letter.
Polycarp encodes each word in the following way: he writes down the median letter of the word, then deletes it and repeats the process until there are no letters left. For example, he encodes the word volga as logva.
You are given an encoding s of some word, your task is to decode it.
Input
The first line contains a positive integer n (1 β€ n β€ 2000) β the length of the encoded word.
The second line contains the string s of length n consisting of lowercase English letters β the encoding.
Output
Print the word that Polycarp encoded.
Examples
Input
5
logva
Output
volga
Input
2
no
Output
no
Input
4
abba
Output
baba
Note
In the first example Polycarp encoded the word volga. At first, he wrote down the letter l from the position 3, after that his word looked like voga. After that Polycarp wrote down the letter o from the position 2, his word became vga. Then Polycarp wrote down the letter g which was at the second position, the word became va. Then he wrote down the letter v, then the letter a. Thus, the encoding looked like logva.
In the second example Polycarp encoded the word no. He wrote down the letter n, the word became o, and he wrote down the letter o. Thus, in this example, the word and its encoding are the same.
In the third example Polycarp encoded the word baba. At first, he wrote down the letter a, which was at the position 2, after that the word looked like bba. Then he wrote down the letter b, which was at the position 2, his word looked like ba. After that he wrote down the letter b, which was at the position 1, the word looked like a, and he wrote down that letter a. Thus, the encoding is abba. | def solve():
input()
ls = [x for x in input()]
return ''.join(ls[-2::-2] + ls[not len(ls)&1::2])
print(solve()) | {
"input": [
"2\nno\n",
"4\nabba\n",
"5\nlogva\n"
],
"output": [
"no\n",
"baba\n",
"volga\n"
]
} |
4,722 | 8 | Polycarp studies at the university in the group which consists of n students (including himself). All they are registrated in the social net "TheContacnt!".
Not all students are equally sociable. About each student you know the value ai β the maximum number of messages which the i-th student is agree to send per day. The student can't send messages to himself.
In early morning Polycarp knew important news that the programming credit will be tomorrow. For this reason it is necessary to urgently inform all groupmates about this news using private messages.
Your task is to make a plan of using private messages, so that:
* the student i sends no more than ai messages (for all i from 1 to n);
* all students knew the news about the credit (initially only Polycarp knew it);
* the student can inform the other student only if he knows it himself.
Let's consider that all students are numerated by distinct numbers from 1 to n, and Polycarp always has the number 1.
In that task you shouldn't minimize the number of messages, the moment of time, when all knew about credit or some other parameters. Find any way how to use private messages which satisfies requirements above.
Input
The first line contains the positive integer n (2 β€ n β€ 100) β the number of students.
The second line contains the sequence a1, a2, ..., an (0 β€ ai β€ 100), where ai equals to the maximum number of messages which can the i-th student agree to send. Consider that Polycarp always has the number 1.
Output
Print -1 to the first line if it is impossible to inform all students about credit.
Otherwise, in the first line print the integer k β the number of messages which will be sent. In each of the next k lines print two distinct integers f and t, meaning that the student number f sent the message with news to the student number t. All messages should be printed in chronological order. It means that the student, who is sending the message, must already know this news. It is assumed that students can receive repeated messages with news of the credit.
If there are several answers, it is acceptable to print any of them.
Examples
Input
4
1 2 1 0
Output
3
1 2
2 4
2 3
Input
6
2 0 1 3 2 0
Output
6
1 3
3 4
1 2
4 5
5 6
4 6
Input
3
0 2 2
Output
-1
Note
In the first test Polycarp (the student number 1) can send the message to the student number 2, who after that can send the message to students number 3 and 4. Thus, all students knew about the credit. | def dfs(v):
was[v] = 1
cnt = 0
for i in range(v + 1, n):
if cnt >= a[v][0]:
break
if not was[i]:
cnt += 1
ans.append((a[v][1], a[i][1]))
dfs(i)
n = int(input())
a = list(map(int, input().split()))
a = [(a[i], i + 1) for i in range(n)]
a = [a[0]] + sorted(a[1:])[::-1]
ans = []
was = [0] * n
dfs(0)
if was.count(0):
print(-1)
else:
print(len(ans))
[print(*i) for i in ans] | {
"input": [
"3\n0 2 2\n",
"4\n1 2 1 0\n",
"6\n2 0 1 3 2 0\n"
],
"output": [
"-1\n",
"3\n1 2\n2 3\n2 4\n",
"5\n1 4\n1 5\n4 3\n4 6\n4 2\n"
]
} |
4,723 | 8 | Woken up by the alarm clock Igor the financial analyst hurried up to the work. He ate his breakfast and sat in his car. Sadly, when he opened his GPS navigator, he found that some of the roads in Bankopolis, the city where he lives, are closed due to road works. Moreover, Igor has some problems with the steering wheel, so he can make no more than two turns on his way to his office in bank.
Bankopolis looks like a grid of n rows and m columns. Igor should find a way from his home to the bank that has no more than two turns and doesn't contain cells with road works, or determine that it is impossible and he should work from home. A turn is a change in movement direction. Igor's car can only move to the left, to the right, upwards and downwards. Initially Igor can choose any direction. Igor is still sleepy, so you should help him.
Input
The first line contains two integers n and m (1 β€ n, m β€ 1000) β the number of rows and the number of columns in the grid.
Each of the next n lines contains m characters denoting the corresponding row of the grid. The following characters can occur:
* "." β an empty cell;
* "*" β a cell with road works;
* "S" β the cell where Igor's home is located;
* "T" β the cell where Igor's office is located.
It is guaranteed that "S" and "T" appear exactly once each.
Output
In the only line print "YES" if there is a path between Igor's home and Igor's office with no more than two turns, and "NO" otherwise.
Examples
Input
5 5
..S..
****.
T....
****.
.....
Output
YES
Input
5 5
S....
****.
.....
.****
..T..
Output
NO
Note
The first sample is shown on the following picture:
<image>
In the second sample it is impossible to reach Igor's office using less that 4 turns, thus there exists no path using no more than 2 turns. The path using exactly 4 turns is shown on this picture:
<image> | import sys
input = sys.stdin.readline
def q(sx, sy, gx, gy):
for i in range(sx, gx+1):
for j in range(sy, gy+1):
if S[i][j]=='*':
return False
return True
n, m = map(int, input().split())
S = [input()[:-1] for _ in range(n)]
for i in range(n):
for j in range(m):
if S[i][j]=='S':
Sx, Sy = i, j
if S[i][j]=='T':
Tx, Ty = i, j
for i in range(n):
if q(min(i, Sx), Sy, max(i, Sx), Sy) and q(i, min(Sy, Ty), i, max(Sy, Ty)) and q(min(i, Tx), Ty, max(i, Tx), Ty):
print('YES')
exit()
for i in range(m):
if q(Sx, min(i, Sy), Sx, max(i, Sy)) and q(min(Sx, Tx), i, max(Sx, Tx), i) and q(Tx, min(i, Ty), Tx, max(i, Ty)):
print('YES')
exit()
print('NO') | {
"input": [
"5 5\n..S..\n****.\nT....\n****.\n.....\n",
"5 5\nS....\n****.\n.....\n.****\n..T..\n"
],
"output": [
"YES",
"NO"
]
} |
4,724 | 12 | A string a of length m is called antipalindromic iff m is even, and for each i (1 β€ i β€ m) ai β am - i + 1.
Ivan has a string s consisting of n lowercase Latin letters; n is even. He wants to form some string t that will be an antipalindromic permutation of s. Also Ivan has denoted the beauty of index i as bi, and the beauty of t as the sum of bi among all indices i such that si = ti.
Help Ivan to determine maximum possible beauty of t he can get.
Input
The first line contains one integer n (2 β€ n β€ 100, n is even) β the number of characters in s.
The second line contains the string s itself. It consists of only lowercase Latin letters, and it is guaranteed that its letters can be reordered to form an antipalindromic string.
The third line contains n integer numbers b1, b2, ..., bn (1 β€ bi β€ 100), where bi is the beauty of index i.
Output
Print one number β the maximum possible beauty of t.
Examples
Input
8
abacabac
1 1 1 1 1 1 1 1
Output
8
Input
8
abaccaba
1 2 3 4 5 6 7 8
Output
26
Input
8
abacabca
1 2 3 4 4 3 2 1
Output
17 | from collections import Counter
r = lambda: map(int, input().split())
def main():
n, = r()
s = input()
cost = list(r())
ans = 0
cnt = Counter()
for i in range(n // 2):
if s[i] == s[n - 1 - i]:
ans += min(cost[i], cost[n - 1 - i])
cnt[s[i]] += 1
total = sum(cnt.values())
if total > 0:
ch, occ = cnt.most_common(1)[0]
avail = []
if occ > total - occ:
for i in range(n // 2):
if s[i] != s[n - 1 - i] and s[i] != ch and s[n - 1 - i] != ch:
avail.append(min(cost[i], cost[n - 1 - i]))
avail.sort()
ans += sum(avail[:2 * occ - total])
print(sum(cost) - ans)
main()
| {
"input": [
"8\nabaccaba\n1 2 3 4 5 6 7 8\n",
"8\nabacabac\n1 1 1 1 1 1 1 1\n",
"8\nabacabca\n1 2 3 4 4 3 2 1\n"
],
"output": [
"26\n",
"8\n",
"17\n"
]
} |
4,725 | 8 | Vasya and Kolya play a game with a string, using the following rules. Initially, Kolya creates a string s, consisting of small English letters, and uniformly at random chooses an integer k from a segment [0, len(s) - 1]. He tells Vasya this string s, and then shifts it k letters to the left, i. e. creates a new string t = sk + 1sk + 2... sns1s2... sk. Vasya does not know the integer k nor the string t, but he wants to guess the integer k. To do this, he asks Kolya to tell him the first letter of the new string, and then, after he sees it, open one more letter on some position, which Vasya can choose.
Vasya understands, that he can't guarantee that he will win, but he wants to know the probability of winning, if he plays optimally. He wants you to compute this probability.
Note that Vasya wants to know the value of k uniquely, it means, that if there are at least two cyclic shifts of s that fit the information Vasya knowns, Vasya loses. Of course, at any moment of the game Vasya wants to maximize the probability of his win.
Input
The only string contains the string s of length l (3 β€ l β€ 5000), consisting of small English letters only.
Output
Print the only number β the answer for the problem. You answer is considered correct, if its absolute or relative error does not exceed 10 - 6.
Formally, let your answer be a, and the jury's answer be b. Your answer is considered correct if <image>
Examples
Input
technocup
Output
1.000000000000000
Input
tictictactac
Output
0.333333333333333
Input
bbaabaabbb
Output
0.100000000000000
Note
In the first example Vasya can always open the second letter after opening the first letter, and the cyclic shift is always determined uniquely.
In the second example if the first opened letter of t is "t" or "c", then Vasya can't guess the shift by opening only one other letter. On the other hand, if the first letter is "i" or "a", then he can open the fourth letter and determine the shift uniquely. | s=input()
def uniq(iii):
tmp=0
for jj in range(1,len(s)):
bb={}
for ii in iii:
bb.setdefault(s[ii-jj],[]).append(ii)
tmp=max(tmp,sum(1 for vvv in bb.values() if len(vvv)==1))
return tmp
aa={}
for ii,ss in enumerate(s):
aa.setdefault(ss,[]).append(ii)
ans=0
for iii in aa.values():
ans+=uniq(iii)
print(ans/len(s))
| {
"input": [
"technocup\n",
"tictictactac\n",
"bbaabaabbb\n"
],
"output": [
"1.000000",
"0.333333",
"0.100000"
]
} |
4,726 | 8 | One day Alex decided to remember childhood when computers were not too powerful and lots of people played only default games. Alex enjoyed playing Minesweeper that time. He imagined that he saved world from bombs planted by terrorists, but he rarely won.
Alex has grown up since then, so he easily wins the most difficult levels. This quickly bored him, and he thought: what if the computer gave him invalid fields in the childhood and Alex could not win because of it?
He needs your help to check it.
A Minesweeper field is a rectangle n Γ m, where each cell is either empty, or contains a digit from 1 to 8, or a bomb. The field is valid if for each cell:
* if there is a digit k in the cell, then exactly k neighboring cells have bombs.
* if the cell is empty, then all neighboring cells have no bombs.
Two cells are neighbors if they have a common side or a corner (i. e. a cell has at most 8 neighboring cells).
Input
The first line contains two integers n and m (1 β€ n, m β€ 100) β the sizes of the field.
The next n lines contain the description of the field. Each line contains m characters, each of them is "." (if this cell is empty), "*" (if there is bomb in this cell), or a digit from 1 to 8, inclusive.
Output
Print "YES", if the field is valid and "NO" otherwise.
You can choose the case (lower or upper) for each letter arbitrarily.
Examples
Input
3 3
111
1*1
111
Output
YES
Input
2 4
*.*.
1211
Output
NO
Note
In the second example the answer is "NO" because, if the positions of the bombs are preserved, the first line of the field should be *2*1.
You can read more about Minesweeper in Wikipedia's article. | n, m = map(int, input().split())
g = [input().replace('.', '0') for i in range(n)]
def f(r, c):
v = sum(g[i][j] == '*' for i in range(max(0, r - 1), min(n, r + 2)) for j in range(max(0, c - 1), min(m, c + 2)))
return v == int(g[r][c])
print('YES' if all(g[i][j] == '*' or f(i, j) for i in range(n) for j in range(m)) else 'NO') | {
"input": [
"2 4\n*.*.\n1211\n",
"3 3\n111\n1*1\n111\n"
],
"output": [
"NO",
"YES"
]
} |
4,727 | 9 | Alice got an array of length n as a birthday present once again! This is the third year in a row!
And what is more disappointing, it is overwhelmengly boring, filled entirely with zeros. Bob decided to apply some changes to the array to cheer up Alice.
Bob has chosen m changes of the following form. For some integer numbers x and d, he chooses an arbitrary position i (1 β€ i β€ n) and for every j β [1, n] adds x + d β
dist(i, j) to the value of the j-th cell. dist(i, j) is the distance between positions i and j (i.e. dist(i, j) = |i - j|, where |x| is an absolute value of x).
For example, if Alice currently has an array [2, 1, 2, 2] and Bob chooses position 3 for x = -1 and d = 2 then the array will become [2 - 1 + 2 β
2,~1 - 1 + 2 β
1,~2 - 1 + 2 β
0,~2 - 1 + 2 β
1] = [5, 2, 1, 3]. Note that Bob can't choose position i outside of the array (that is, smaller than 1 or greater than n).
Alice will be the happiest when the elements of the array are as big as possible. Bob claimed that the arithmetic mean value of the elements will work fine as a metric.
What is the maximum arithmetic mean value Bob can achieve?
Input
The first line contains two integers n and m (1 β€ n, m β€ 10^5) β the number of elements of the array and the number of changes.
Each of the next m lines contains two integers x_i and d_i (-10^3 β€ x_i, d_i β€ 10^3) β the parameters for the i-th change.
Output
Print the maximal average arithmetic mean of the elements Bob can achieve.
Your answer is considered correct if its absolute or relative error doesn't exceed 10^{-6}.
Examples
Input
2 3
-1 3
0 0
-1 -4
Output
-2.500000000000000
Input
3 2
0 2
5 0
Output
7.000000000000000 | n,m = list(map(int, input().split()))
avg = 0
def s(p):
return p*(p+1)//2
for i in range(m):
x,d = list(map(int, input().split()))
avg += (n*x + max( d*s(n-1), d*(s(n//2)+s((n-1)//2))))
#print(avg)
print("%.15f" % (avg/n))
| {
"input": [
"2 3\n-1 3\n0 0\n-1 -4\n",
"3 2\n0 2\n5 0\n"
],
"output": [
"-2.5\n",
"7.0\n"
]
} |
4,728 | 12 | Vova has taken his summer practice this year and now he should write a report on how it went.
Vova has already drawn all the tables and wrote down all the formulas. Moreover, he has already decided that the report will consist of exactly n pages and the i-th page will include x_i tables and y_i formulas. The pages are numbered from 1 to n.
Vova fills the pages one after another, he can't go filling page i + 1 before finishing page i and he can't skip pages.
However, if he draws strictly more than k tables in a row or writes strictly more than k formulas in a row then he will get bored. Vova wants to rearrange tables and formulas in each page in such a way that he doesn't get bored in the process. Vova can't move some table or some formula to another page.
Note that the count doesn't reset on the start of the new page. For example, if the page ends with 3 tables and the next page starts with 5 tables, then it's counted as 8 tables in a row.
Help Vova to determine if he can rearrange tables and formulas on each page in such a way that there is no more than k tables in a row and no more than k formulas in a row.
Input
The first line contains two integers n and k (1 β€ n β€ 3 β
10^5, 1 β€ k β€ 10^6).
The second line contains n integers x_1, x_2, ..., x_n (1 β€ x_i β€ 10^6) β the number of tables on the i-th page.
The third line contains n integers y_1, y_2, ..., y_n (1 β€ y_i β€ 10^6) β the number of formulas on the i-th page.
Output
Print "YES" if Vova can rearrange tables and formulas on each page in such a way that there is no more than k tables in a row and no more than k formulas in a row.
Otherwise print "NO".
Examples
Input
2 2
5 5
2 2
Output
YES
Input
2 2
5 6
2 2
Output
NO
Input
4 1
4 1 10 1
3 2 10 1
Output
YES
Note
In the first example the only option to rearrange everything is the following (let table be 'T' and formula be 'F'):
* page 1: "TTFTTFT"
* page 2: "TFTTFTT"
That way all blocks of tables have length 2.
In the second example there is no way to fit everything in such a way that there are no more than 2 tables in a row and 2 formulas in a row. | def max(a, b):
if a > b:
return a
return b
n, k = map(int, input().split())
o = [int(t) for t in (input()+' '+input()).split()]
f, s = 0, 0
for i in range(n):
f = max(0, o[i] + f - k * o[i+n])
s = max(0, o[i+n] + s - k * o[i])
if f > k or s > k:
print('NO')
exit(0)
print('YES') | {
"input": [
"4 1\n4 1 10 1\n3 2 10 1\n",
"2 2\n5 6\n2 2\n",
"2 2\n5 5\n2 2\n"
],
"output": [
"YES\n",
"NO\n",
"YES\n"
]
} |
4,729 | 12 | You are given an undirected tree of n vertices.
Some vertices are colored blue, some are colored red and some are uncolored. It is guaranteed that the tree contains at least one red vertex and at least one blue vertex.
You choose an edge and remove it from the tree. Tree falls apart into two connected components. Let's call an edge nice if neither of the resulting components contain vertices of both red and blue colors.
How many nice edges are there in the given tree?
Input
The first line contains a single integer n (2 β€ n β€ 3 β
10^5) β the number of vertices in the tree.
The second line contains n integers a_1, a_2, ..., a_n (0 β€ a_i β€ 2) β the colors of the vertices. a_i = 1 means that vertex i is colored red, a_i = 2 means that vertex i is colored blue and a_i = 0 means that vertex i is uncolored.
The i-th of the next n - 1 lines contains two integers v_i and u_i (1 β€ v_i, u_i β€ n, v_i β u_i) β the edges of the tree. It is guaranteed that the given edges form a tree. It is guaranteed that the tree contains at least one red vertex and at least one blue vertex.
Output
Print a single integer β the number of nice edges in the given tree.
Examples
Input
5
2 0 0 1 2
1 2
2 3
2 4
2 5
Output
1
Input
5
1 0 0 0 2
1 2
2 3
3 4
4 5
Output
4
Input
3
1 1 2
2 3
1 3
Output
0
Note
Here is the tree from the first example:
<image>
The only nice edge is edge (2, 4). Removing it makes the tree fall apart into components \{4\} and \{1, 2, 3, 5\}. The first component only includes a red vertex and the second component includes blue vertices and uncolored vertices.
Here is the tree from the second example:
<image>
Every edge is nice in it.
Here is the tree from the third example:
<image>
Edge (1, 3) splits the into components \{1\} and \{3, 2\}, the latter one includes both red and blue vertex, thus the edge isn't nice. Edge (2, 3) splits the into components \{1, 3\} and \{2\}, the former one includes both red and blue vertex, thus the edge also isn't nice. So the answer is 0. | from collections import deque
import sys
input = sys.stdin.readline
def bfs(s):
q = deque()
q.append(s)
visit = [0] * (n + 1)
visit[s] = 1
parent = [-1] * (n + 1)
p = []
while q:
i = q.popleft()
p.append(i)
for j in G[i]:
if not visit[j]:
q.append(j)
visit[j] = 1
parent[j] = i
return parent, p
n = int(input())
a = list(map(int, input().split()))
cnt = [0] * 3
for i in a:
cnt[i] += 1
G = [[] for _ in range(n + 1)]
for _ in range(n - 1):
u, v = map(int, input().split())
G[u].append(v)
G[v].append(u)
parent, p = bfs(1)
dpr, dpb = [0] * (n + 1), [0] * (n + 1)
ans = 0
for _ in range(n - 1):
i = p.pop()
j = parent[i]
if a[i - 1] == 1:
dpr[i] += 1
elif a[i - 1] == 2:
dpb[i] += 1
if (not dpr[i] and dpb[i] == cnt[2]) or (not dpb[i] and dpr[i] == cnt[1]):
ans += 1
dpr[j] += dpr[i]
dpb[j] += dpb[i]
print(ans) | {
"input": [
"5\n1 0 0 0 2\n1 2\n2 3\n3 4\n4 5\n",
"3\n1 1 2\n2 3\n1 3\n",
"5\n2 0 0 1 2\n1 2\n2 3\n2 4\n2 5\n"
],
"output": [
"4\n",
"0\n",
"1\n"
]
} |
4,730 | 9 | <image>
Input
The input contains a single integer a (0 β€ a β€ 15).
Output
Output a single integer.
Example
Input
3
Output
13 | def reverseBits(n) :
rev = 0
for i in range(4):
rev = rev << 1
if (n & 1 == 1) :
rev = rev ^ 1
n = n >> 1
return rev
n= int(input())
n=reverseBits(n);
n-=1;
print(reverseBits(n));
| {
"input": [
"3\n"
],
"output": [
"13\n"
]
} |
4,731 | 8 | Tom loves vowels, and he likes long words with many vowels. His favorite words are vowelly words. We say a word of length k is vowelly if there are positive integers n and m such that nβ
m = k and when the word is written by using n rows and m columns (the first row is filled first, then the second and so on, with each row filled from left to right), every vowel of the English alphabet appears at least once in every row and every column.
You are given an integer k and you must either print a vowelly word of length k or print -1 if no such word exists.
In this problem the vowels of the English alphabet are 'a', 'e', 'i', 'o' ,'u'.
Input
Input consists of a single line containing the integer k (1β€ k β€ 10^4) β the required length.
Output
The output must consist of a single line, consisting of a vowelly word of length k consisting of lowercase English letters if it exists or -1 if it does not.
If there are multiple possible words, you may output any of them.
Examples
Input
7
Output
-1
Input
36
Output
agoeuioaeiruuimaeoieauoweouoiaouimae
Note
In the second example, the word "agoeuioaeiruuimaeoieauoweouoiaouimae" can be arranged into the following 6 Γ 6 grid:
<image>
It is easy to verify that every row and every column contain all the vowels. | def main():
k = int(input())
for i in range(5, k // 5 + 1):
if k % i == 0:
break
else:
print(-1)
return
m = k // i
for j in range(i):
s = "aeiou"
s = s[j % 5:] + s[:j % 5]
s = s * (m // 5) + s[:m % 5]
print(s, end = "")
main() | {
"input": [
"36\n",
"7\n"
],
"output": [
"aeiouaeiouaeiouaeiouaeiouaeiouaeioua\n",
"-1\n"
]
} |
4,732 | 10 | The only difference between easy and hard versions is the length of the string.
You are given a string s and a string t, both consisting only of lowercase Latin letters. It is guaranteed that t can be obtained from s by removing some (possibly, zero) number of characters (not necessary contiguous) from s without changing order of remaining characters (in other words, it is guaranteed that t is a subsequence of s).
For example, the strings "test", "tst", "tt", "et" and "" are subsequences of the string "test". But the strings "tset", "se", "contest" are not subsequences of the string "test".
You want to remove some substring (contiguous subsequence) from s of maximum possible length such that after removing this substring t will remain a subsequence of s.
If you want to remove the substring s[l;r] then the string s will be transformed to s_1 s_2 ... s_{l-1} s_{r+1} s_{r+2} ... s_{|s|-1} s_{|s|} (where |s| is the length of s).
Your task is to find the maximum possible length of the substring you can remove so that t is still a subsequence of s.
Input
The first line of the input contains one string s consisting of at least 1 and at most 2 β
10^5 lowercase Latin letters.
The second line of the input contains one string t consisting of at least 1 and at most 2 β
10^5 lowercase Latin letters.
It is guaranteed that t is a subsequence of s.
Output
Print one integer β the maximum possible length of the substring you can remove so that t is still a subsequence of s.
Examples
Input
bbaba
bb
Output
3
Input
baaba
ab
Output
2
Input
abcde
abcde
Output
0
Input
asdfasdf
fasd
Output
3 | def f(s,t):
right=[0]*(len(t))
for i in reversed(range(len(t))):
pos=len(s)-1
if i+1<len(t):
pos=right[i+1]-1
while s[pos]!=t[i]:
pos-=1
right[i]=pos
ans=0
pos=0
for i in range(len(s)):
rpos=len(s)-1
if pos<len(t):
rpos=right[pos]-1
ans=max(ans,rpos-i+1)
if pos<len(t) and t[pos]==s[i]:
pos+=1
return ans
s=input()
t=input()
print(f(s,t)) | {
"input": [
"abcde\nabcde\n",
"baaba\nab\n",
"bbaba\nbb\n",
"asdfasdf\nfasd\n"
],
"output": [
"0\n",
"2\n",
"3\n",
"3\n"
]
} |
4,733 | 8 | Sasha grew up and went to first grade. To celebrate this event her mother bought her a multiplication table M with n rows and n columns such that M_{ij}=a_i β
a_j where a_1, ..., a_n is some sequence of positive integers.
Of course, the girl decided to take it to school with her. But while she was having lunch, hooligan Grisha erased numbers on the main diagonal and threw away the array a_1, ..., a_n. Help Sasha restore the array!
Input
The first line contains a single integer n (3 β©½ n β©½ 10^3), the size of the table.
The next n lines contain n integers each. The j-th number of the i-th line contains the number M_{ij} (1 β€ M_{ij} β€ 10^9). The table has zeroes on the main diagonal, that is, M_{ii}=0.
Output
In a single line print n integers, the original array a_1, ..., a_n (1 β€ a_i β€ 10^9). It is guaranteed that an answer exists. If there are multiple answers, print any.
Examples
Input
5
0 4 6 2 4
4 0 6 2 4
6 6 0 3 6
2 2 3 0 2
4 4 6 2 0
Output
2 2 3 1 2
Input
3
0 99990000 99970002
99990000 0 99980000
99970002 99980000 0
Output
9999 10000 9998 | import sys
import math as m
def fi():
return sys.stdin.readline()
if __name__ == '__main__':
n = int(fi())
l = []
for i in range (n):
l.append(list(map(int, fi().split())))
a = m.ceil((l[2][0]*l[1][0]/l[2][1])**0.5)
print(a,end=' ')
for i in range(1,n):
print(l[i][0]//a,end=' ') | {
"input": [
"5\n0 4 6 2 4\n4 0 6 2 4\n6 6 0 3 6\n2 2 3 0 2\n4 4 6 2 0\n",
"3\n0 99990000 99970002\n99990000 0 99980000\n99970002 99980000 0\n"
],
"output": [
"2 2 3 1 2 ",
"9999 10000 9998 "
]
} |
4,734 | 10 | Shichikuji is the new resident deity of the South Black Snail Temple. Her first job is as follows:
There are n new cities located in Prefecture X. Cities are numbered from 1 to n. City i is located x_i km North of the shrine and y_i km East of the shrine. It is possible that (x_i, y_i) = (x_j, y_j) even when i β j.
Shichikuji must provide electricity to each city either by building a power station in that city, or by making a connection between that city and another one that already has electricity. So the City has electricity if it has a power station in it or it is connected to a City which has electricity by a direct connection or via a chain of connections.
* Building a power station in City i will cost c_i yen;
* Making a connection between City i and City j will cost k_i + k_j yen per km of wire used for the connection. However, wires can only go the cardinal directions (North, South, East, West). Wires can cross each other. Each wire must have both of its endpoints in some cities. If City i and City j are connected by a wire, the wire will go through any shortest path from City i to City j. Thus, the length of the wire if City i and City j are connected is |x_i - x_j| + |y_i - y_j| km.
Shichikuji wants to do this job spending as little money as possible, since according to her, there isn't really anything else in the world other than money. However, she died when she was only in fifth grade so she is not smart enough for this. And thus, the new resident deity asks for your help.
And so, you have to provide Shichikuji with the following information: minimum amount of yen needed to provide electricity to all cities, the cities in which power stations will be built, and the connections to be made.
If there are multiple ways to choose the cities and the connections to obtain the construction of minimum price, then print any of them.
Input
First line of input contains a single integer n (1 β€ n β€ 2000) β the number of cities.
Then, n lines follow. The i-th line contains two space-separated integers x_i (1 β€ x_i β€ 10^6) and y_i (1 β€ y_i β€ 10^6) β the coordinates of the i-th city.
The next line contains n space-separated integers c_1, c_2, ..., c_n (1 β€ c_i β€ 10^9) β the cost of building a power station in the i-th city.
The last line contains n space-separated integers k_1, k_2, ..., k_n (1 β€ k_i β€ 10^9).
Output
In the first line print a single integer, denoting the minimum amount of yen needed.
Then, print an integer v β the number of power stations to be built.
Next, print v space-separated integers, denoting the indices of cities in which a power station will be built. Each number should be from 1 to n and all numbers should be pairwise distinct. You can print the numbers in arbitrary order.
After that, print an integer e β the number of connections to be made.
Finally, print e pairs of integers a and b (1 β€ a, b β€ n, a β b), denoting that a connection between City a and City b will be made. Each unordered pair of cities should be included at most once (for each (a, b) there should be no more (a, b) or (b, a) pairs). You can print the pairs in arbitrary order.
If there are multiple ways to choose the cities and the connections to obtain the construction of minimum price, then print any of them.
Examples
Input
3
2 3
1 1
3 2
3 2 3
3 2 3
Output
8
3
1 2 3
0
Input
3
2 1
1 2
3 3
23 2 23
3 2 3
Output
27
1
2
2
1 2
2 3
Note
For the answers given in the samples, refer to the following diagrams (cities with power stations are colored green, other cities are colored blue, and wires are colored red):
<image>
For the first example, the cost of building power stations in all cities is 3 + 2 + 3 = 8. It can be shown that no configuration costs less than 8 yen.
For the second example, the cost of building a power station in City 2 is 2. The cost of connecting City 1 and City 2 is 2 β
(3 + 2) = 10. The cost of connecting City 2 and City 3 is 3 β
(2 + 3) = 15. Thus the total cost is 2 + 10 + 15 = 27. It can be shown that no configuration costs less than 27 yen. | def dist(a,b):
return abs(a[0] - b[0]) + abs(a[1] - b[1])
n = int(input())
p = []
for i in range(n):
p.append(list(map(int, input().split())))
c = list(map(int, input().split()))
k = list(map(int, input().split()))
st = []
ed = []
ans = 0
is_st = [1] * n
parent = [-1] * n
d = { i: c[i] for i in range(n)}
for i in range(n):
m = min(d, key = d.get)
if(is_st[m]):
st.append(m)
else:
ed.append([m, parent[m]])
ans = ans + d[m]
del d[m]
for j in d.keys():
t_cost = (k[m] + k[j])*dist(p[m], p[j])
if(t_cost < d[j]):
d[j] = t_cost
parent[j] = m
is_st[j] = 0
print(ans)
print(len(st))
for i in st:
print(i+1,end = " ")
print()
print(len(ed))
for i in ed:
print(i[0]+1,i[1]+1)
| {
"input": [
"3\n2 1\n1 2\n3 3\n23 2 23\n3 2 3\n",
"3\n2 3\n1 1\n3 2\n3 2 3\n3 2 3\n"
],
"output": [
"27\n1\n2 \n2\n1 2\n2 3\n",
"8\n3\n2 1 3 \n0\n"
]
} |
4,735 | 8 | You are given a permutation p=[p_1, p_2, β¦, p_n] of integers from 1 to n. Let's call the number m (1 β€ m β€ n) beautiful, if there exists two indices l, r (1 β€ l β€ r β€ n), such that the numbers [p_l, p_{l+1}, β¦, p_r] is a permutation of numbers 1, 2, β¦, m.
For example, let p = [4, 5, 1, 3, 2, 6]. In this case, the numbers 1, 3, 5, 6 are beautiful and 2, 4 are not. It is because:
* if l = 3 and r = 3 we will have a permutation [1] for m = 1;
* if l = 3 and r = 5 we will have a permutation [1, 3, 2] for m = 3;
* if l = 1 and r = 5 we will have a permutation [4, 5, 1, 3, 2] for m = 5;
* if l = 1 and r = 6 we will have a permutation [4, 5, 1, 3, 2, 6] for m = 6;
* it is impossible to take some l and r, such that [p_l, p_{l+1}, β¦, p_r] is a permutation of numbers 1, 2, β¦, m for m = 2 and for m = 4.
You are given a permutation p=[p_1, p_2, β¦, p_n]. For all m (1 β€ m β€ n) determine if it is a beautiful number or not.
Input
The first line contains the only integer t (1 β€ t β€ 1000) β the number of test cases in the input. The next lines contain the description of test cases.
The first line of a test case contains a number n (1 β€ n β€ 2 β
10^5) β the length of the given permutation p. The next line contains n integers p_1, p_2, β¦, p_n (1 β€ p_i β€ n, all p_i are different) β the given permutation p.
It is guaranteed, that the sum of n from all test cases in the input doesn't exceed 2 β
10^5.
Output
Print t lines β the answers to test cases in the order they are given in the input.
The answer to a test case is the string of length n, there the i-th character is equal to 1 if i is a beautiful number and is equal to 0 if i is not a beautiful number.
Example
Input
3
6
4 5 1 3 2 6
5
5 3 1 2 4
4
1 4 3 2
Output
101011
11111
1001
Note
The first test case is described in the problem statement.
In the second test case all numbers from 1 to 5 are beautiful:
* if l = 3 and r = 3 we will have a permutation [1] for m = 1;
* if l = 3 and r = 4 we will have a permutation [1, 2] for m = 2;
* if l = 2 and r = 4 we will have a permutation [3, 1, 2] for m = 3;
* if l = 2 and r = 5 we will have a permutation [3, 1, 2, 4] for m = 4;
* if l = 1 and r = 5 we will have a permutation [5, 3, 1, 2, 4] for m = 5. | def solve():
n=(int)(input())
p=input().split()
inv=[0 for i in range(n+1)]
for i in range(n):
p[i],inv[(int)(p[i])]=(int)(p[i]),i
output=""
mx,mn=0,n
for i in range(1,n+1):
mx,mn=max(inv[i],mx),min(inv[i],mn)
output+="1" if mx-mn+1==i else "0"
return output
t=(int)(input())
for Test in range(t):
print(solve()) | {
"input": [
"3\n6\n4 5 1 3 2 6\n5\n5 3 1 2 4\n4\n1 4 3 2\n"
],
"output": [
"101011\n11111\n1001\n"
]
} |
4,736 | 12 | Kuroni is very angry at the other setters for using him as a theme! As a punishment, he forced them to solve the following problem:
You have an array a consisting of n positive integers. An operation consists of choosing an element and either adding 1 to it or subtracting 1 from it, such that the element remains positive. We say the array is good if the greatest common divisor of all its elements is not 1. Find the minimum number of operations needed to make the array good.
Unable to match Kuroni's intellect, the setters failed to solve the problem. Help them escape from Kuroni's punishment!
Input
The first line contains an integer n (2 β€ n β€ 2 β
10^5) β the number of elements in the array.
The second line contains n integers a_1, a_2, ..., a_n. (1 β€ a_i β€ 10^{12}) β the elements of the array.
Output
Print a single integer β the minimum number of operations required to make the array good.
Examples
Input
3
6 2 4
Output
0
Input
5
9 8 7 3 1
Output
4
Note
In the first example, the first array is already good, since the greatest common divisor of all the elements is 2.
In the second example, we may apply the following operations:
1. Add 1 to the second element, making it equal to 9.
2. Subtract 1 from the third element, making it equal to 6.
3. Add 1 to the fifth element, making it equal to 2.
4. Add 1 to the fifth element again, making it equal to 3.
The greatest common divisor of all elements will then be equal to 3, so the array will be good. It can be shown that no sequence of three or less operations can make the array good. | import random
n = int(input())
a = list(map(int, input().split()))
def add(x):
d = 2
while d * d <= x:
if x % d == 0:
primes.add(d)
while x % d == 0:
x //= d
d += 1
if x > 1:
primes.add(x)
ans = float('inf')
primes = {2}
for x in random.choices(a, k=min(n, 8)):
for dx in range(-1, 2):
add(x + dx)
for p in primes:
cand = 0
for x in a:
if x < p:
cand += p - x
else:
r = x % p
cand += min(r, p-r)
ans = min(ans, cand)
if ans==0: break
print(ans)
| {
"input": [
"3\n6 2 4\n",
"5\n9 8 7 3 1\n"
],
"output": [
"0\n",
"4\n"
]
} |
4,737 | 9 | A lot of people associate Logo programming language with turtle graphics. In this case the turtle moves along the straight line and accepts commands "T" ("turn around") and "F" ("move 1 unit forward").
You are given a list of commands that will be given to the turtle. You have to change exactly n commands from the list (one command can be changed several times). How far from the starting point can the turtle move after it follows all the commands of the modified list?
Input
The first line of input contains a string commands β the original list of commands. The string commands contains between 1 and 100 characters, inclusive, and contains only characters "T" and "F".
The second line contains an integer n (1 β€ n β€ 50) β the number of commands you have to change in the list.
Output
Output the maximum distance from the starting point to the ending point of the turtle's path. The ending point of the turtle's path is turtle's coordinate after it follows all the commands of the modified list.
Examples
Input
FT
1
Output
2
Input
FFFTFFF
2
Output
6
Note
In the first example the best option is to change the second command ("T") to "F" β this way the turtle will cover a distance of 2 units.
In the second example you have to change two commands. One of the ways to cover maximal distance of 6 units is to change the fourth command and first or last one. | from sys import stdin
s=stdin.readline().strip()
k=int(stdin.readline().strip())
n=len(s)
dp=[[[[[ None for ty in range(2)]for tt in range(2)]for i in range(2)] for j in range(k+1)] for k1 in range(n)]
def sol(i,j,t,c,mt):
if i==n:
if j!=0:
if mt:
return -10001
else:
return 10001
else:
return 0
if dp[i][j][t][c][mt]!=None:
return dp[i][j][t][c][mt]
ans=0
if c==-1:
c=(s[i]=="F")
if c:
if t:
ans=-1+sol(i+1,j,t,-1,mt)
else:
ans=1+sol(i+1,j,t,-1,mt)
if j>0:
if mt:
ans=max(ans,sol(i,j-1, t,0,mt))
else:
ans=min(ans,sol(i,j-1, t,0,mt))
else :
ans=sol(i+1,j,not t,-1,mt)
if j>0:
if mt:
ans=max(ans,sol(i,j-1, t,1,mt))
else:
ans=min(ans,sol(i,j-1, t,1,mt))
dp[i][j][t][c][mt]=ans
return dp[i][j][t][c][mt]
print(max(-sol(0,k,0,-1,0),sol(0,k,0,-1,1)))
| {
"input": [
"FFFTFFF\n2\n",
"FT\n1\n"
],
"output": [
"6\n",
"2\n"
]
} |
4,738 | 7 | You are given a sequence of positive integers a1, a2, ..., an. Find all such indices i, that the i-th element equals the arithmetic mean of all other elements (that is all elements except for this one).
Input
The first line contains the integer n (2 β€ n β€ 2Β·105). The second line contains elements of the sequence a1, a2, ..., an (1 β€ ai β€ 1000). All the elements are positive integers.
Output
Print on the first line the number of the sought indices. Print on the second line the sought indices in the increasing order. All indices are integers from 1 to n.
If the sought elements do not exist, then the first output line should contain number 0. In this case you may either not print the second line or print an empty line.
Examples
Input
5
1 2 3 4 5
Output
1
3
Input
4
50 50 50 50
Output
4
1 2 3 4 | """
codeforces 134A
"""
def moyenne():
a = int(input())
b = [int(x) for x in input().split()]
z = sum(b)
recup = [i + 1 for i, x in enumerate(b) if (z - x) / (a - 1) == x]
return recup
def main():
moy = moyenne()
print(len(moy))
print(*moy)
if __name__ == "__main__":
main()
| {
"input": [
"5\n1 2 3 4 5\n",
"4\n50 50 50 50\n"
],
"output": [
"1\n3\n",
"4\n1 2 3 4\n"
]
} |
4,739 | 7 | Let's consider all integers in the range from 1 to n (inclusive).
Among all pairs of distinct integers in this range, find the maximum possible greatest common divisor of integers in pair. Formally, find the maximum value of gcd(a, b), where 1 β€ a < b β€ n.
The greatest common divisor, gcd(a, b), of two positive integers a and b is the biggest integer that is a divisor of both a and b.
Input
The first line contains a single integer t (1 β€ t β€ 100) β the number of test cases. The description of the test cases follows.
The only line of each test case contains a single integer n (2 β€ n β€ 10^6).
Output
For each test case, output the maximum value of gcd(a, b) among all 1 β€ a < b β€ n.
Example
Input
2
3
5
Output
1
2
Note
In the first test case, gcd(1, 2) = gcd(2, 3) = gcd(1, 3) = 1.
In the second test case, 2 is the maximum possible value, corresponding to gcd(2, 4). | def gcd():
for s in[*open(0)][1:]:print(int(s)//2)
gcd() | {
"input": [
"2\n3\n5\n"
],
"output": [
"1\n2\n"
]
} |
4,740 | 12 | Omkar is standing at the foot of Celeste mountain. The summit is n meters away from him, and he can see all of the mountains up to the summit, so for all 1 β€ j β€ n he knows that the height of the mountain at the point j meters away from himself is h_j meters. It turns out that for all j satisfying 1 β€ j β€ n - 1, h_j < h_{j + 1} (meaning that heights are strictly increasing).
Suddenly, a landslide occurs! While the landslide is occurring, the following occurs: every minute, if h_j + 2 β€ h_{j + 1}, then one square meter of dirt will slide from position j + 1 to position j, so that h_{j + 1} is decreased by 1 and h_j is increased by 1. These changes occur simultaneously, so for example, if h_j + 2 β€ h_{j + 1} and h_{j + 1} + 2 β€ h_{j + 2} for some j, then h_j will be increased by 1, h_{j + 2} will be decreased by 1, and h_{j + 1} will be both increased and decreased by 1, meaning that in effect h_{j + 1} is unchanged during that minute.
The landslide ends when there is no j such that h_j + 2 β€ h_{j + 1}. Help Omkar figure out what the values of h_1, ..., h_n will be after the landslide ends. It can be proven that under the given constraints, the landslide will always end in finitely many minutes.
Note that because of the large amount of input, it is recommended that your code uses fast IO.
Input
The first line contains a single integer n (1 β€ n β€ 10^6).
The second line contains n integers h_1, h_2, ..., h_n satisfying 0 β€ h_1 < h_2 < ... < h_n β€ 10^{12} β the heights.
Output
Output n integers, where the j-th integer is the value of h_j after the landslide has stopped.
Example
Input
4
2 6 7 8
Output
5 5 6 7
Note
Initially, the mountain has heights 2, 6, 7, 8.
In the first minute, we have 2 + 2 β€ 6, so 2 increases to 3 and 6 decreases to 5, leaving 3, 5, 7, 8.
In the second minute, we have 3 + 2 β€ 5 and 5 + 2 β€ 7, so 3 increases to 4, 5 is unchanged, and 7 decreases to 6, leaving 4, 5, 6, 8.
In the third minute, we have 6 + 2 β€ 8, so 6 increases to 7 and 8 decreases to 7, leaving 4, 5, 7, 7.
In the fourth minute, we have 5 + 2 β€ 7, so 5 increases to 6 and 7 decreases to 6, leaving 4, 6, 6, 7.
In the fifth minute, we have 4 + 2 β€ 6, so 4 increases to 5 and 6 decreases to 5, leaving 5, 5, 6, 7.
In the sixth minute, nothing else can change so the landslide stops and our answer is 5, 5, 6, 7. | from sys import stdin, stdout
input = stdin.buffer.readline
print = stdout.write
def f(a, b):
return (a + b) * n // 2
n = int(input())
*h, = map(int, input().split())
s = sum(h)
l, r = 0, 10 ** 12
while l < r:
m = l + r >> 1
if f(m, m + n - 1) < s:
l = m + 1
else:
r = m
l -= 1
y = f(l, l + n - 1)
for i in range(n):
print(f'{l + i + (i < s - y)} ')
| {
"input": [
"4\n2 6 7 8\n"
],
"output": [
"5 5 6 7 "
]
} |
4,741 | 8 | RedDreamer has an array a consisting of n non-negative integers, and an unlucky integer T.
Let's denote the misfortune of array b having length m as f(b) β the number of pairs of integers (i, j) such that 1 β€ i < j β€ m and b_i + b_j = T. RedDreamer has to paint each element of a into one of two colors, white and black (for each element, the color is chosen independently), and then create two arrays c and d so that all white elements belong to c, and all black elements belong to d (it is possible that one of these two arrays becomes empty). RedDreamer wants to paint the elements in such a way that f(c) + f(d) is minimum possible.
For example:
* if n = 6, T = 7 and a = [1, 2, 3, 4, 5, 6], it is possible to paint the 1-st, the 4-th and the 5-th elements white, and all other elements black. So c = [1, 4, 5], d = [2, 3, 6], and f(c) + f(d) = 0 + 0 = 0;
* if n = 3, T = 6 and a = [3, 3, 3], it is possible to paint the 1-st element white, and all other elements black. So c = [3], d = [3, 3], and f(c) + f(d) = 0 + 1 = 1.
Help RedDreamer to paint the array optimally!
Input
The first line contains one integer t (1 β€ t β€ 1000) β the number of test cases. Then t test cases follow.
The first line of each test case contains two integers n and T (1 β€ n β€ 10^5, 0 β€ T β€ 10^9) β the number of elements in the array and the unlucky integer, respectively.
The second line contains n integers a_1, a_2, ..., a_n (0 β€ a_i β€ 10^9) β the elements of the array.
The sum of n over all test cases does not exceed 10^5.
Output
For each test case print n integers: p_1, p_2, ..., p_n (each p_i is either 0 or 1) denoting the colors. If p_i is 0, then a_i is white and belongs to the array c, otherwise it is black and belongs to the array d.
If there are multiple answers that minimize the value of f(c) + f(d), print any of them.
Example
Input
2
6 7
1 2 3 4 5 6
3 6
3 3 3
Output
1 0 0 1 1 0
1 0 0 |
def solve(lst,k):
dicts={}
ans=[]
flag=0
for i in lst:
if i*2 ==k:
ans.append(flag)
flag=1-flag
elif i*2 < k:
ans.append('1')
else:
ans.append('0')
return ' '.join([str(i) for i in ans])
m = int(input())
for i in range(m):
k,m = map(int,input().split(' '))
lst = list(map(int,input().split(' ')))
print(solve(lst,m)) | {
"input": [
"2\n6 7\n1 2 3 4 5 6\n3 6\n3 3 3\n"
],
"output": [
"0 0 0 1 1 1\n0 1 0\n"
]
} |
4,742 | 7 | Sayaka Saeki is a member of the student council, which has n other members (excluding Sayaka). The i-th member has a height of a_i millimeters.
It's the end of the school year and Sayaka wants to take a picture of all other members of the student council. Being the hard-working and perfectionist girl as she is, she wants to arrange all the members in a line such that the amount of photogenic consecutive pairs of members is as large as possible.
A pair of two consecutive members u and v on a line is considered photogenic if their average height is an integer, i.e. (a_u + a_v)/(2) is an integer.
Help Sayaka arrange the other members to maximize the number of photogenic consecutive pairs.
Input
The first line contains a single integer t (1β€ tβ€ 500) β the number of test cases.
The first line of each test case contains a single integer n (2 β€ n β€ 2000) β the number of other council members.
The second line of each test case contains n integers a_1, a_2, ..., a_n (1 β€ a_i β€ 2 β
10^5) β the heights of each of the other members in millimeters.
It is guaranteed that the sum of n over all test cases does not exceed 2000.
Output
For each test case, output on one line n integers representing the heights of the other members in the order, which gives the largest number of photogenic consecutive pairs. If there are multiple such orders, output any of them.
Example
Input
4
3
1 1 2
3
1 1 1
8
10 9 13 15 3 16 9 13
2
18 9
Output
1 1 2
1 1 1
13 9 13 15 3 9 16 10
9 18
Note
In the first test case, there is one photogenic pair: (1, 1) is photogenic, as (1+1)/(2)=1 is integer, while (1, 2) isn't, as (1+2)/(2)=1.5 isn't integer.
In the second test case, both pairs are photogenic. | def sol1(arr,n):
j = -1
for i in range(0, n) :
if (arr[i] % 2 == 0) :
j += 1
arr[i], arr[j]= arr[j], arr[i]
for _ in range(int(input())):
n = int(input())
arr = list(map(int,input().split()))
sol1(arr,n)
print(*arr) | {
"input": [
"4\n3\n1 1 2\n3\n1 1 1\n8\n10 9 13 15 3 16 9 13\n2\n18 9\n"
],
"output": [
"\n1 1 2 \n1 1 1 \n13 9 13 15 3 9 16 10 \n9 18 \n"
]
} |
4,743 | 7 | Four players participate in the playoff tournament. The tournament is held according to the following scheme: the first player will play with the second, and the third player with the fourth, then the winners of the pairs will play in the finals of the tournament.
It is known that in a match between two players, the one whose skill is greater will win. The skill of the i-th player is equal to s_i and all skill levels are pairwise different (i. e. there are no two identical values in the array s).
The tournament is called fair if the two players with the highest skills meet in the finals.
Determine whether the given tournament is fair.
Input
The first line contains a single integer t (1 β€ t β€ 10^4) β the number of test cases.
A single line of test case contains four integers s_1, s_2, s_3, s_4 (1 β€ s_i β€ 100) β skill of the players. It is guaranteed that all the numbers in the array are different.
Output
For each testcase, output YES if the tournament is fair, or NO otherwise.
Example
Input
4
3 7 9 5
4 5 6 9
5 3 8 1
6 5 3 2
Output
YES
NO
YES
NO
Note
Consider the example:
1. in the first test case, players 2 and 3 with skills 7 and 9 advance to the finals;
2. in the second test case, players 2 and 4 with skills 5 and 9 advance to the finals. The player with skill 6 does not advance, but the player with skill 5 advances to the finals, so the tournament is not fair;
3. in the third test case, players 1 and 3 with skills 5 and 8 advance to the finals;
4. in the fourth test case, players 1 and 3 with skills 6 and 3 advance to the finals. The player with skill 5 does not advance, but the player with skill 3 advances to the finals, so the tournament is not fair. |
def solve(s):
l=max(s[0],s[1])
p=max(s[2],s[3])
if ((s[2]>l) and (s[3]>l)) or ((s[1]>p) and (s[0]>p)):
print("NO")
else:
print("YES")
n = int(input())
for i in range(n):
s = list(map(int,input().split()))
solve(s)
| {
"input": [
"4\n3 7 9 5\n4 5 6 9\n5 3 8 1\n6 5 3 2\n"
],
"output": [
"\nYES\nNO\nYES\nNO\n"
]
} |
4,744 | 9 | The Little Elephant very much loves sums on intervals.
This time he has a pair of integers l and r (l β€ r). The Little Elephant has to find the number of such integers x (l β€ x β€ r), that the first digit of integer x equals the last one (in decimal notation). For example, such numbers as 101, 477474 or 9 will be included in the answer and 47, 253 or 1020 will not.
Help him and count the number of described numbers x for a given pair l and r.
Input
The single line contains a pair of integers l and r (1 β€ l β€ r β€ 1018) β the boundaries of the interval.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use cin, cout streams or the %I64d specifier.
Output
On a single line print a single integer β the answer to the problem.
Examples
Input
2 47
Output
12
Input
47 1024
Output
98
Note
In the first sample the answer includes integers 2, 3, 4, 5, 6, 7, 8, 9, 11, 22, 33, 44. | def f(x): return x if x<10 else x//10+9-(0 if str(x)[0]<=str(x)[-1] else 1)
l, r = map(int,input().split())
print(f(r)-f(l-1))
# Made By Mostafa_Khaled | {
"input": [
"47 1024\n",
"2 47\n"
],
"output": [
"98\n",
"12\n"
]
} |
4,745 | 8 | Bob wants to put a new bargaining table in his office. To do so he measured the office room thoroughly and drew its plan: Bob's office room is a rectangular room n Γ m meters. Each square meter of the room is either occupied by some furniture, or free. A bargaining table is rectangular, and should be placed so, that its sides are parallel to the office walls. Bob doesn't want to change or rearrange anything, that's why all the squares that will be occupied by the table should be initially free. Bob wants the new table to sit as many people as possible, thus its perimeter should be maximal. Help Bob find out the maximum possible perimeter of a bargaining table for his office.
Input
The first line contains 2 space-separated numbers n and m (1 β€ n, m β€ 25) β the office room dimensions. Then there follow n lines with m characters 0 or 1 each. 0 stands for a free square meter of the office room. 1 stands for an occupied square meter. It's guaranteed that at least one square meter in the room is free.
Output
Output one number β the maximum possible perimeter of a bargaining table for Bob's office room.
Examples
Input
3 3
000
010
000
Output
8
Input
5 4
1100
0000
0000
0000
0000
Output
16 | n, m = map(int, input().split())
input = [input() for _ in range(n)]
d = []
for _ in range(n):
d.append([0 for _ in range(m)])
def a(i,j):
return 0 if i<0 or j<0 else d[i][j]
for i in range(n):
for j in range(m):
d[i][j] = int(input[i][j]) - a(i-1,j-1) + a(i,j-1) + a(i-1,j)
p = 0
for i in range(n):
for j in range(m):
for u in range(i, n):
for v in range(j, m):
x = a(u,v) - a(u,j-1) - a(i-1,v) + a(i-1,j-1)
if x == 0:
p = max(p, u + v - i - j)
print(p + p + 4) | {
"input": [
"3 3\n000\n010\n000\n",
"5 4\n1100\n0000\n0000\n0000\n0000\n"
],
"output": [
"8",
"16"
]
} |
4,746 | 7 | Greg is a beginner bodybuilder. Today the gym coach gave him the training plan. All it had was n integers a1, a2, ..., an. These numbers mean that Greg needs to do exactly n exercises today. Besides, Greg should repeat the i-th in order exercise ai times.
Greg now only does three types of exercises: "chest" exercises, "biceps" exercises and "back" exercises. Besides, his training is cyclic, that is, the first exercise he does is a "chest" one, the second one is "biceps", the third one is "back", the fourth one is "chest", the fifth one is "biceps", and so on to the n-th exercise.
Now Greg wonders, which muscle will get the most exercise during his training. We know that the exercise Greg repeats the maximum number of times, trains the corresponding muscle the most. Help Greg, determine which muscle will get the most training.
Input
The first line contains integer n (1 β€ n β€ 20). The second line contains n integers a1, a2, ..., an (1 β€ ai β€ 25) β the number of times Greg repeats the exercises.
Output
Print word "chest" (without the quotes), if the chest gets the most exercise, "biceps" (without the quotes), if the biceps gets the most exercise and print "back" (without the quotes) if the back gets the most exercise.
It is guaranteed that the input is such that the answer to the problem is unambiguous.
Examples
Input
2
2 8
Output
biceps
Input
3
5 1 10
Output
back
Input
7
3 3 2 7 9 6 8
Output
chest
Note
In the first sample Greg does 2 chest, 8 biceps and zero back exercises, so the biceps gets the most exercises.
In the second sample Greg does 5 chest, 1 biceps and 10 back exercises, so the back gets the most exercises.
In the third sample Greg does 18 chest, 12 biceps and 8 back exercises, so the chest gets the most exercise. | def answer():
a = int(input())
c = [int(x) for x in input().split()]
i=0
d=[0,0,0]
e=["chest","biceps","back"]
while i<len(c):
d[i%3]+=c[i]
i+=1
print(e[d.index(max(d))])
answer()
| {
"input": [
"3\n5 1 10\n",
"7\n3 3 2 7 9 6 8\n",
"2\n2 8\n"
],
"output": [
"back\n",
"chest\n",
"biceps\n"
]
} |
4,747 | 7 | Valera the horse lives on a plane. The Cartesian coordinate system is defined on this plane. Also an infinite spiral is painted on the plane. The spiral consists of segments: [(0, 0), (1, 0)], [(1, 0), (1, 1)], [(1, 1), ( - 1, 1)], [( - 1, 1), ( - 1, - 1)], [( - 1, - 1), (2, - 1)], [(2, - 1), (2, 2)] and so on. Thus, this infinite spiral passes through each integer point of the plane.
Valera the horse lives on the plane at coordinates (0, 0). He wants to walk along the spiral to point (x, y). Valera the horse has four legs, so he finds turning very difficult. Count how many times he will have to turn if he goes along a spiral from point (0, 0) to point (x, y).
Input
The first line contains two space-separated integers x and y (|x|, |y| β€ 100).
Output
Print a single integer, showing how many times Valera has to turn.
Examples
Input
0 0
Output
0
Input
1 0
Output
0
Input
0 1
Output
2
Input
-1 -1
Output
3 | def spiral():
X,Y=list(map(int ,input().split()))
x = y = 0
dx = 0
dy = -1
turn=0
if(X==0 and Y==0):
turn=1;
else:
while(1):
if(x==X and y==Y):
break
if x == y or (x < 0 and x == -y) or (x > 0 and x == 1-y):
dx, dy = -dy, dx
turn+=1
x, y = x+dx, y+dy
print(turn-1)
spiral();
| {
"input": [
"1 0\n",
"0 0\n",
"0 1\n",
"-1 -1\n"
],
"output": [
"0\n",
"0\n",
"2\n",
"3\n"
]
} |
4,748 | 9 | There is a long plate s containing n digits. Iahub wants to delete some digits (possibly none, but he is not allowed to delete all the digits) to form his "magic number" on the plate, a number that is divisible by 5. Note that, the resulting number may contain leading zeros.
Now Iahub wants to count the number of ways he can obtain magic number, modulo 1000000007 (109 + 7). Two ways are different, if the set of deleted positions in s differs.
Look at the input part of the statement, s is given in a special form.
Input
In the first line you're given a string a (1 β€ |a| β€ 105), containing digits only. In the second line you're given an integer k (1 β€ k β€ 109). The plate s is formed by concatenating k copies of a together. That is n = |a|Β·k.
Output
Print a single integer β the required number of ways modulo 1000000007 (109 + 7).
Examples
Input
1256
1
Output
4
Input
13990
2
Output
528
Input
555
2
Output
63
Note
In the first case, there are four possible ways to make a number that is divisible by 5: 5, 15, 25 and 125.
In the second case, remember to concatenate the copies of a. The actual plate is 1399013990.
In the third case, except deleting all digits, any choice will do. Therefore there are 26 - 1 = 63 possible ways to delete digits. | def invmod( x , y , MOD ):
return (x*pow(y,MOD-2,MOD))%MOD
s=input()
k=int(input())
n=len(s)
MOD=10**9+7
sumG = invmod( pow(2,k*n,MOD)-1 , pow(2,n,MOD)-1 , MOD)
ans=0
for i in range(len(s)):
if(s[i]=='5' or s[i]=='0'):
ans+=pow(2,i,MOD)
ans*=sumG
print(ans%MOD)
| {
"input": [
"1256\n1\n",
"555\n2\n",
"13990\n2\n"
],
"output": [
"4",
"63",
"528"
]
} |
4,749 | 9 | One day, at the "Russian Code Cup" event it was decided to play football as an out of competition event. All participants was divided into n teams and played several matches, two teams could not play against each other more than once.
The appointed Judge was the most experienced member β Pavel. But since he was the wisest of all, he soon got bored of the game and fell asleep. Waking up, he discovered that the tournament is over and the teams want to know the results of all the matches.
Pavel didn't want anyone to discover about him sleeping and not keeping an eye on the results, so he decided to recover the results of all games. To do this, he asked all the teams and learned that the real winner was friendship, that is, each team beat the other teams exactly k times. Help Pavel come up with chronology of the tournir that meets all the conditions, or otherwise report that there is no such table.
Input
The first line contains two integers β n and k (1 β€ n, k β€ 1000).
Output
In the first line print an integer m β number of the played games. The following m lines should contain the information about all the matches, one match per line. The i-th line should contain two integers ai and bi (1 β€ ai, bi β€ n; ai β bi). The numbers ai and bi mean, that in the i-th match the team with number ai won against the team with number bi. You can assume, that the teams are numbered from 1 to n.
If a tournir that meets the conditions of the problem does not exist, then print -1.
Examples
Input
3 1
Output
3
1 2
2 3
3 1 | def pair(a,b):
if a>b:
return pair(b,a)
else:
return (((a + b) * (a + b + 1)) / 2) + b
(n,k)=list(map(int,input().split()))
if k>int((n-1)/2):
print("-1")
else:
print(n*k)
hash={}
for i in range(1,n+1):
j=1
count=0
while j<=n and count<k:
if i==j:
j+=1
continue
else:
p=pair(i,j)
if p in hash:
j+=1
continue
else:
hash[p]=1
print("%d %d"%(i,j))
count+=1
j+=1 | {
"input": [
"3 1\n"
],
"output": [
"3\n1 2\n2 3\n3 1\n"
]
} |
4,750 | 7 | DZY loves Physics, and he enjoys calculating density.
Almost everything has density, even a graph. We define the density of a non-directed graph (nodes and edges of the graph have some values) as follows:
<image> where v is the sum of the values of the nodes, e is the sum of the values of the edges.
Once DZY got a graph G, now he wants to find a connected induced subgraph G' of the graph, such that the density of G' is as large as possible.
An induced subgraph G'(V', E') of a graph G(V, E) is a graph that satisfies:
* <image>;
* edge <image> if and only if <image>, and edge <image>;
* the value of an edge in G' is the same as the value of the corresponding edge in G, so as the value of a node.
Help DZY to find the induced subgraph with maximum density. Note that the induced subgraph you choose must be connected.
<image>
Input
The first line contains two space-separated integers n (1 β€ n β€ 500), <image>. Integer n represents the number of nodes of the graph G, m represents the number of edges.
The second line contains n space-separated integers xi (1 β€ xi β€ 106), where xi represents the value of the i-th node. Consider the graph nodes are numbered from 1 to n.
Each of the next m lines contains three space-separated integers ai, bi, ci (1 β€ ai < bi β€ n; 1 β€ ci β€ 103), denoting an edge between node ai and bi with value ci. The graph won't contain multiple edges.
Output
Output a real number denoting the answer, with an absolute or relative error of at most 10 - 9.
Examples
Input
1 0
1
Output
0.000000000000000
Input
2 1
1 2
1 2 1
Output
3.000000000000000
Input
5 6
13 56 73 98 17
1 2 56
1 3 29
1 4 42
2 3 95
2 4 88
3 4 63
Output
2.965517241379311
Note
In the first sample, you can only choose an empty subgraph, or the subgraph containing only node 1.
In the second sample, choosing the whole graph is optimal. | import sys
def input(): return sys.stdin.readline().strip()
n,m=map(int, input().split())
w=list(map(int, input().split()))
ans=0.0
for i in range(m):
u,v,c=map(int, input().split())
ans=max(ans, round( (w[u-1]+w[v-1])/c,9))
print(ans)
| {
"input": [
"5 6\n13 56 73 98 17\n1 2 56\n1 3 29\n1 4 42\n2 3 95\n2 4 88\n3 4 63\n",
"1 0\n1\n",
"2 1\n1 2\n1 2 1\n"
],
"output": [
"2.9655172414\n",
"0.0000000000\n",
"3.0000000000\n"
]
} |
4,751 | 8 | The start of the new academic year brought about the problem of accommodation students into dormitories. One of such dormitories has a a Γ b square meter wonder room. The caretaker wants to accommodate exactly n students there. But the law says that there must be at least 6 square meters per student in a room (that is, the room for n students must have the area of at least 6n square meters). The caretaker can enlarge any (possibly both) side of the room by an arbitrary positive integer of meters. Help him change the room so as all n students could live in it and the total area of the room was as small as possible.
Input
The first line contains three space-separated integers n, a and b (1 β€ n, a, b β€ 109) β the number of students and the sizes of the room.
Output
Print three integers s, a1 and b1 (a β€ a1; b β€ b1) β the final area of the room and its sizes. If there are multiple optimal solutions, print any of them.
Examples
Input
3 3 5
Output
18
3 6
Input
2 4 4
Output
16
4 4 | a, b, c = map(int, input().split(' '))
def solve(a, b, c):
if b >= c:
b, c = c, b
for i in range(max(6*a, b*c), 10**50):
for j in range(b, int(i**0.5)+1):
if i%j==0:
if int(i/j)>=c:
return (i, j, int(i/j))
x, y, z = solve(a, b, c)
print(x)
if y>=b and z>=c:
print(y, z)
else:
print(z, y)
| {
"input": [
"3 3 5\n",
"2 4 4\n"
],
"output": [
"18\n3 6\n",
"16\n4 4\n"
]
} |
4,752 | 12 | An n Γ n square matrix is special, if:
* it is binary, that is, each cell contains either a 0, or a 1;
* the number of ones in each row and column equals 2.
You are given n and the first m rows of the matrix. Print the number of special n Γ n matrices, such that the first m rows coincide with the given ones.
As the required value can be rather large, print the remainder after dividing the value by the given number mod.
Input
The first line of the input contains three integers n, m, mod (2 β€ n β€ 500, 0 β€ m β€ n, 2 β€ mod β€ 109). Then m lines follow, each of them contains n characters β the first rows of the required special matrices. Each of these lines contains exactly two characters '1', the rest characters are '0'. Each column of the given m Γ n table contains at most two numbers one.
Output
Print the remainder after dividing the required value by number mod.
Examples
Input
3 1 1000
011
Output
2
Input
4 4 100500
0110
1010
0101
1001
Output
1
Note
For the first test the required matrices are:
011
101
110
011
110
101
In the second test the required matrix is already fully given, so the answer is 1. | from math import *
from collections import *
import sys
sys.setrecursionlimit(10**9)
dp = [[-1 for i in range(505)] for j in range(505)]
def memo(row,z,o):
if(row == n):
if(z == 0 and o == 0):
return 1
else:
return 0
if(dp[z][o] != -1): return dp[z][o]
if(z > 1):
dp[z][o] += (z*(z-1)//2)*(memo(row+1,z-2,o+2))
dp[z][o] %= mod
if(z >= 1 and o >= 1):
dp[z][o] += (z*o)*(memo(row+1,z-1,o))
dp[z][o] %= mod
if(o > 1):
dp[z][o] += (o*(o-1)//2)*(memo(row+1,z,o-2))
dp[z][o] %= mod
#print(row,z,o,dp[z][o])
dp[z][o] += 1
dp[z][o] %= mod
return dp[z][o]%mod
n,m,mod = map(int,input().split())
a = []
for i in range(m):
s = list(input())
a.append(s)
#print(a)
ct = [0 for i in range(n)]
for i in range(m):
for j in range(n):
if(a[i][j] == '1'):
ct[j] += 1
z = ct.count(0)
o = ct.count(1)
ans = memo(m,z,o)
print(ans%mod)
| {
"input": [
"4 4 100500\n0110\n1010\n0101\n1001\n",
"3 1 1000\n011\n"
],
"output": [
"1\n",
"2\n"
]
} |
4,753 | 12 | Andrew skipped lessons on the subject 'Algorithms and Data Structures' for the entire term. When he came to the final test, the teacher decided to give him a difficult task as a punishment.
The teacher gave Andrew an array of n numbers a1, ..., an. After that he asked Andrew for each k from 1 to n - 1 to build a k-ary heap on the array and count the number of elements for which the property of the minimum-rooted heap is violated, i.e. the value of an element is less than the value of its parent.
Andrew looked up on the Wikipedia that a k-ary heap is a rooted tree with vertices in elements of the array. If the elements of the array are indexed from 1 to n, then the children of element v are elements with indices k(v - 1) + 2, ..., kv + 1 (if some of these elements lie outside the borders of the array, the corresponding children are absent). In any k-ary heap every element except for the first one has exactly one parent; for the element 1 the parent is absent (this element is the root of the heap). Denote p(v) as the number of the parent of the element with the number v. Let's say that for a non-root element v the property of the heap is violated if av < ap(v).
Help Andrew cope with the task!
Input
The first line contains a single integer n (2 β€ n β€ 2Β·105).
The second line contains n space-separated integers a1, ..., an ( - 109 β€ ai β€ 109).
Output
in a single line print n - 1 integers, separate the consecutive numbers with a single space β the number of elements for which the property of the k-ary heap is violated, for k = 1, 2, ..., n - 1.
Examples
Input
5
1 5 4 3 2
Output
3 2 1 0
Input
6
2 2 2 2 2 2
Output
0 0 0 0 0
Note
Pictures with the heaps for the first sample are given below; elements for which the property of the heap is violated are marked with red.
<image> <image> <image> <image>
In the second sample all elements are equal, so the property holds for all pairs. | import sys
def myargsort(a):
b = list(zip(a, range(0, len(a))))
b.sort()
r = [pr[1] for pr in b]
return r
fin = sys.stdin
n = int(fin.readline())
a = [int(number) for number in fin.readline().split()]
p = myargsort(a)
p.reverse()
j = 0
aib = [0] * (n + 1)
def ultb(x):
return -(x ^ (-x)) // 2
def add(p, a, aib, n):
while p <= n:
aib[p] += a
p += ultb(p)
def suma(p, aib):
r = 0
while p > 0:
r += aib[p]
p -= ultb(p)
return r
for i in range(0, n):
add(i + 1, 1, aib, n)
r = [0] * (n + 1)
for i in range(0, n):
if i > 0 and a[i - 1] > a[i]:
r[1] += 1
while j < n and a[p[j]] == a[p[i]]:
add(p[j] + 1, -1, aib, n)
j += 1
k = 2
while k < n and p[i] * k + 1 < n:
dr = min(n, p[i] * k + k + 1)
st = p[i] * k + 2
r[k] += suma(dr, aib) - suma(st - 1, aib)
k += 1
print(*r[1:n])
| {
"input": [
"6\n2 2 2 2 2 2\n",
"5\n1 5 4 3 2\n"
],
"output": [
"0 0 0 0 0 ",
"3 2 1 0 "
]
} |
4,754 | 8 | Duff is in love with lovely numbers! A positive integer x is called lovely if and only if there is no such positive integer a > 1 such that a2 is a divisor of x.
<image>
Malek has a number store! In his store, he has only divisors of positive integer n (and he has all of them). As a birthday present, Malek wants to give her a lovely number from his store. He wants this number to be as big as possible.
Malek always had issues in math, so he asked for your help. Please tell him what is the biggest lovely number in his store.
Input
The first and only line of input contains one integer, n (1 β€ n β€ 1012).
Output
Print the answer in one line.
Examples
Input
10
Output
10
Input
12
Output
6
Note
In first sample case, there are numbers 1, 2, 5 and 10 in the shop. 10 isn't divisible by any perfect square, so 10 is lovely.
In second sample case, there are numbers 1, 2, 3, 4, 6 and 12 in the shop. 12 is divisible by 4 = 22, so 12 is not lovely, while 6 is indeed lovely. | def main():
n = int(input())
i = 2
while n >= i ** 2:
while n % i ** 2 == 0:
n //= i
i += 1
print(n)
main()
| {
"input": [
"12\n",
"10\n"
],
"output": [
"6\n",
"10\n"
]
} |
4,755 | 7 | Vasya lives in a round building, whose entrances are numbered sequentially by integers from 1 to n. Entrance n and entrance 1 are adjacent.
Today Vasya got bored and decided to take a walk in the yard. Vasya lives in entrance a and he decided that during his walk he will move around the house b entrances in the direction of increasing numbers (in this order entrance n should be followed by entrance 1). The negative value of b corresponds to moving |b| entrances in the order of decreasing numbers (in this order entrance 1 is followed by entrance n). If b = 0, then Vasya prefers to walk beside his entrance.
<image> Illustration for n = 6, a = 2, b = - 5.
Help Vasya to determine the number of the entrance, near which he will be at the end of his walk.
Input
The single line of the input contains three space-separated integers n, a and b (1 β€ n β€ 100, 1 β€ a β€ n, - 100 β€ b β€ 100) β the number of entrances at Vasya's place, the number of his entrance and the length of his walk, respectively.
Output
Print a single integer k (1 β€ k β€ n) β the number of the entrance where Vasya will be at the end of his walk.
Examples
Input
6 2 -5
Output
3
Input
5 1 3
Output
4
Input
3 2 7
Output
3
Note
The first example is illustrated by the picture in the statements. | def f():
[n,a,b] = list(map(int,input().split(' ')))
print((a+b%n-1)%n+1)
f() | {
"input": [
"3 2 7\n",
"6 2 -5\n",
"5 1 3\n"
],
"output": [
"3\n",
"3\n",
"4\n"
]
} |
4,756 | 9 | Petya has recently learned data structure named "Binary heap".
The heap he is now operating with allows the following operations:
* put the given number into the heap;
* get the value of the minimum element in the heap;
* extract the minimum element from the heap;
Thus, at any moment of time the heap contains several integers (possibly none), some of them might be equal.
In order to better learn this data structure Petya took an empty heap and applied some operations above to it. Also, he carefully wrote down all the operations and their results to his event log, following the format:
* insert x β put the element with value x in the heap;
* getMin x β the value of the minimum element contained in the heap was equal to x;
* removeMin β the minimum element was extracted from the heap (only one instance, if there were many).
All the operations were correct, i.e. there was at least one element in the heap each time getMin or removeMin operations were applied.
While Petya was away for a lunch, his little brother Vova came to the room, took away some of the pages from Petya's log and used them to make paper boats.
Now Vova is worried, if he made Petya's sequence of operations inconsistent. For example, if one apply operations one-by-one in the order they are written in the event log, results of getMin operations might differ from the results recorded by Petya, and some of getMin or removeMin operations may be incorrect, as the heap is empty at the moment they are applied.
Now Vova wants to add some new operation records to the event log in order to make the resulting sequence of operations correct. That is, the result of each getMin operation is equal to the result in the record, and the heap is non-empty when getMin ad removeMin are applied. Vova wants to complete this as fast as possible, as the Petya may get back at any moment. He asks you to add the least possible number of operation records to the current log. Note that arbitrary number of operations may be added at the beginning, between any two other operations, or at the end of the log.
Input
The first line of the input contains the only integer n (1 β€ n β€ 100 000) β the number of the records left in Petya's journal.
Each of the following n lines describe the records in the current log in the order they are applied. Format described in the statement is used. All numbers in the input are integers not exceeding 109 by their absolute value.
Output
The first line of the output should contain a single integer m β the minimum possible number of records in the modified sequence of operations.
Next m lines should contain the corrected sequence of records following the format of the input (described in the statement), one per line and in the order they are applied. All the numbers in the output should be integers not exceeding 109 by their absolute value.
Note that the input sequence of operations must be the subsequence of the output sequence.
It's guaranteed that there exists the correct answer consisting of no more than 1 000 000 operations.
Examples
Input
2
insert 3
getMin 4
Output
4
insert 3
removeMin
insert 4
getMin 4
Input
4
insert 1
insert 1
removeMin
getMin 2
Output
6
insert 1
insert 1
removeMin
removeMin
insert 2
getMin 2
Note
In the first sample, after number 3 is inserted into the heap, the minimum number is 3. To make the result of the first getMin equal to 4 one should firstly remove number 3 from the heap and then add number 4 into the heap.
In the second sample case number 1 is inserted two times, so should be similarly removed twice. | from heapq import heappush, heappop
h = []
ans = []
def main():
global h
n = int(input())
for i in range(n):
s = input()
if s[0] == 'i':
data = int(s.split()[1])
heappush(h, data)
ans.append(s)
elif s[0] == 'g':
data = int(s.split()[1])
while h and h[0] < data:
heappop(h)
ans.append('removeMin')
if (not h) or (h[0] > data):
heappush(h, data)
ans.append('insert ' + str(data))
ans.append(s)
else:
if not h:
ans.append('insert 0')
else:
heappop(h)
ans.append('removeMin')
print(len(ans))
print("\n".join(ans))
if __name__ == '__main__':
main()
| {
"input": [
"4\ninsert 1\ninsert 1\nremoveMin\ngetMin 2\n",
"2\ninsert 3\ngetMin 4\n"
],
"output": [
"6\ninsert 1\ninsert 1\nremoveMin\nremoveMin\ninsert 2\ngetMin 2\n",
"4\ninsert 3\nremoveMin\ninsert 4\ngetMin 4\n"
]
} |
4,757 | 7 | Santa Claus is the first who came to the Christmas Olympiad, and he is going to be the first to take his place at a desk! In the classroom there are n lanes of m desks each, and there are two working places at each of the desks. The lanes are numbered from 1 to n from the left to the right, the desks in a lane are numbered from 1 to m starting from the blackboard. Note that the lanes go perpendicularly to the blackboard, not along it (see picture).
The organizers numbered all the working places from 1 to 2nm. The places are numbered by lanes (i. e. all the places of the first lane go first, then all the places of the second lane, and so on), in a lane the places are numbered starting from the nearest to the blackboard (i. e. from the first desk in the lane), at each desk, the place on the left is numbered before the place on the right.
<image> The picture illustrates the first and the second samples.
Santa Clause knows that his place has number k. Help him to determine at which lane at which desk he should sit, and whether his place is on the left or on the right!
Input
The only line contains three integers n, m and k (1 β€ n, m β€ 10 000, 1 β€ k β€ 2nm) β the number of lanes, the number of desks in each lane and the number of Santa Claus' place.
Output
Print two integers: the number of lane r, the number of desk d, and a character s, which stands for the side of the desk Santa Claus. The character s should be "L", if Santa Clause should sit on the left, and "R" if his place is on the right.
Examples
Input
4 3 9
Output
2 2 L
Input
4 3 24
Output
4 3 R
Input
2 4 4
Output
1 2 R
Note
The first and the second samples are shown on the picture. The green place corresponds to Santa Claus' place in the first example, the blue place corresponds to Santa Claus' place in the second example.
In the third sample there are two lanes with four desks in each, and Santa Claus has the fourth place. Thus, his place is in the first lane at the second desk on the right. | def main():
n, m, k = map(int, input().split())
r, k = divmod(k - 1, m * 2)
print(r + 1, k // 2 + 1, 'LR'[k & 1])
if __name__ == '__main__':
main()
| {
"input": [
"2 4 4\n",
"4 3 9\n",
"4 3 24\n"
],
"output": [
"1 2 R\n",
"2 2 L\n",
"4 3 R\n"
]
} |
4,758 | 10 | A sequence of square brackets is regular if by inserting symbols "+" and "1" into it, you can get a regular mathematical expression from it. For example, sequences "[[]][]", "[]" and "[[][[]]]" β are regular, at the same time "][", "[[]" and "[[]]][" β are irregular.
Draw the given sequence using a minimalistic pseudographics in the strip of the lowest possible height β use symbols '+', '-' and '|'. For example, the sequence "[[][]][]" should be represented as:
+- -++- -+
|+- -++- -+|| |
|| || ||| |
|+- -++- -+|| |
+- -++- -+
Each bracket should be represented with the hepl of one or more symbols '|' (the vertical part) and symbols '+' and '-' as on the example which is given above.
Brackets should be drawn without spaces one by one, only dividing pairs of consecutive pairwise brackets with a single-space bar (so that the two brackets do not visually merge into one symbol). The image should have the minimum possible height.
The enclosed bracket is always smaller than the surrounding bracket, but each bracket separately strives to maximize the height of the image. So the pair of final brackets in the example above occupies the entire height of the image.
Study carefully the examples below, they adequately explain the condition of the problem. Pay attention that in this problem the answer (the image) is unique.
Input
The first line contains an even integer n (2 β€ n β€ 100) β the length of the sequence of brackets.
The second line contains the sequence of brackets β these are n symbols "[" and "]". It is guaranteed that the given sequence of brackets is regular.
Output
Print the drawn bracket sequence in the format which is given in the condition. Don't print extra (unnecessary) spaces.
Examples
Input
8
[[][]][]
Output
+- -++- -+
|+- -++- -+|| |
|| || ||| |
|+- -++- -+|| |
+- -++- -+
Input
6
[[[]]]
Output
+- -+
|+- -+|
||+- -+||
||| |||
||+- -+||
|+- -+|
+- -+
Input
6
[[][]]
Output
+- -+
|+- -++- -+|
|| || ||
|+- -++- -+|
+- -+
Input
2
[]
Output
+- -+
| |
+- -+
Input
4
[][]
Output
+- -++- -+
| || |
+- -++- -+ | _, s = input(), input()
MAX_H = 1 + 2 * max(s.count('[', 0, i) - s.count(']', 0, i) for i in range(len(s) + 1))
line = lambda d: '+'.join((' ' * d, '|' * (MAX_H - 2 * d - 2), ' ' * d))
def draw(s, i, d):
return [line(d)] if s[i] == '[' else ([' ' * MAX_H] * 3 if s[i - 1] == '[' else []) + [line(d - 1)]
[print(''.join(x).replace('+ ', '+-').replace(' +', '-+')) for x in zip(*sum((draw(s, i, s.count('[', 0, i) - s.count(']', 0, i)) for i in range(len(s))), []))]
| {
"input": [
"8\n[[][]][]\n",
"6\n[[[]]]\n",
"4\n[][]\n",
"6\n[[][]]\n",
"2\n[]\n"
],
"output": [
"+- -++- -+\n|+- -++- -+|| |\n|| || ||| |\n|+- -++- -+|| |\n+- -++- -+\n",
"+- -+\n|+- -+|\n||+- -+||\n||| |||\n||+- -+||\n|+- -+|\n+- -+\n",
"+- -++- -+\n| || |\n+- -++- -+\n",
"+- -+\n|+- -++- -+|\n|| || ||\n|+- -++- -+|\n+- -+\n",
"+- -+\n| |\n+- -+\n"
]
} |
4,759 | 7 | Karen is getting ready for a new school day!
<image>
It is currently hh:mm, given in a 24-hour format. As you know, Karen loves palindromes, and she believes that it is good luck to wake up when the time is a palindrome.
What is the minimum number of minutes she should sleep, such that, when she wakes up, the time is a palindrome?
Remember that a palindrome is a string that reads the same forwards and backwards. For instance, 05:39 is not a palindrome, because 05:39 backwards is 93:50. On the other hand, 05:50 is a palindrome, because 05:50 backwards is 05:50.
Input
The first and only line of input contains a single string in the format hh:mm (00 β€ hh β€ 23, 00 β€ mm β€ 59).
Output
Output a single integer on a line by itself, the minimum number of minutes she should sleep, such that, when she wakes up, the time is a palindrome.
Examples
Input
05:39
Output
11
Input
13:31
Output
0
Input
23:59
Output
1
Note
In the first test case, the minimum number of minutes Karen should sleep for is 11. She can wake up at 05:50, when the time is a palindrome.
In the second test case, Karen can wake up immediately, as the current time, 13:31, is already a palindrome.
In the third test case, the minimum number of minutes Karen should sleep for is 1 minute. She can wake up at 00:00, when the time is a palindrome. | def b(h, m):
s = '%02d:%02d'%(h, m)
return s == s[::-1]
h, m = map(int, input().split(':'))
ans = 0
while not b(h, m):
ans += 1
m += 1
if m == 60:
m = 0
h = (h+1)%24
print(ans)
| {
"input": [
"23:59\n",
"05:39\n",
"13:31\n"
],
"output": [
"1\n",
"11\n",
"0\n"
]
} |
4,760 | 7 | One day Kefa found n baloons. For convenience, we denote color of i-th baloon as si β lowercase letter of the Latin alphabet. Also Kefa has k friends. Friend will be upset, If he get two baloons of the same color. Kefa want to give out all baloons to his friends. Help Kefa to find out, can he give out all his baloons, such that no one of his friens will be upset β print Β«YESΒ», if he can, and Β«NOΒ», otherwise. Note, that Kefa's friend will not upset, if he doesn't get baloons at all.
Input
The first line contains two integers n and k (1 β€ n, k β€ 100) β the number of baloons and friends.
Next line contains string s β colors of baloons.
Output
Answer to the task β Β«YESΒ» or Β«NOΒ» in a single line.
You can choose the case (lower or upper) for each letter arbitrary.
Examples
Input
4 2
aabb
Output
YES
Input
6 3
aacaab
Output
NO
Note
In the first sample Kefa can give 1-st and 3-rd baloon to the first friend, and 2-nd and 4-th to the second.
In the second sample Kefa needs to give to all his friends baloons of color a, but one baloon will stay, thats why answer is Β«NOΒ». | def check():
for i in range(26):
if s.count( chr(97+i) ) > k:
return False
return True
n , k = map(int,input().split())
s = input()
if check():
print("YES")
else:print("NO") | {
"input": [
"6 3\naacaab\n",
"4 2\naabb\n"
],
"output": [
"NO\n",
"YES\n"
]
} |
4,761 | 8 | Mahmoud and Ehab continue their adventures! As everybody in the evil land knows, Dr. Evil likes bipartite graphs, especially trees.
A tree is a connected acyclic graph. A bipartite graph is a graph, whose vertices can be partitioned into 2 sets in such a way, that for each edge (u, v) that belongs to the graph, u and v belong to different sets. You can find more formal definitions of a tree and a bipartite graph in the notes section below.
Dr. Evil gave Mahmoud and Ehab a tree consisting of n nodes and asked them to add edges to it in such a way, that the graph is still bipartite. Besides, after adding these edges the graph should be simple (doesn't contain loops or multiple edges). What is the maximum number of edges they can add?
A loop is an edge, which connects a node with itself. Graph doesn't contain multiple edges when for each pair of nodes there is no more than one edge between them. A cycle and a loop aren't the same .
Input
The first line of input contains an integer n β the number of nodes in the tree (1 β€ n β€ 105).
The next n - 1 lines contain integers u and v (1 β€ u, v β€ n, u β v) β the description of the edges of the tree.
It's guaranteed that the given graph is a tree.
Output
Output one integer β the maximum number of edges that Mahmoud and Ehab can add to the tree while fulfilling the conditions.
Examples
Input
3
1 2
1 3
Output
0
Input
5
1 2
2 3
3 4
4 5
Output
2
Note
Tree definition: https://en.wikipedia.org/wiki/Tree_(graph_theory)
Bipartite graph definition: <https://en.wikipedia.org/wiki/Bipartite_graph>
In the first test case the only edge that can be added in such a way, that graph won't contain loops or multiple edges is (2, 3), but adding this edge will make the graph non-bipartite so the answer is 0.
In the second test case Mahmoud and Ehab can add edges (1, 4) and (2, 5). | def bfs():
cur = 0
que = [1]
status[1] = 1
while cur != len(que):
u = que[cur]
for v in p[u]:
if status[v] == 0:
status[v] = 0 - status[u]
que.append(v)
cur += 1
n = int(input())
p = [ [] for _ in range(n+10)]
for i in range(n - 1):
u,v = map(int,input().split())
p[u].append(v)
p[v].append(u)
status = [0 for _ in range(n+10)]
bfs()
cnt = 0
for x in status:
if x == 1:
cnt += 1
answer = cnt * (n - cnt) - (n - 1)
print(answer) | {
"input": [
"3\n1 2\n1 3\n",
"5\n1 2\n2 3\n3 4\n4 5\n"
],
"output": [
"0\n",
"2\n"
]
} |
4,762 | 7 | A frog lives on the axis Ox and needs to reach home which is in the point n. She starts from the point 1. The frog can jump to the right at a distance not more than d. So, after she jumped from the point x she can reach the point x + a, where a is an integer from 1 to d.
For each point from 1 to n is known if there is a lily flower in it. The frog can jump only in points with a lilies. Guaranteed that there are lilies in the points 1 and n.
Determine the minimal number of jumps that the frog needs to reach home which is in the point n from the point 1. Consider that initially the frog is in the point 1. If the frog can not reach home, print -1.
Input
The first line contains two integers n and d (2 β€ n β€ 100, 1 β€ d β€ n - 1) β the point, which the frog wants to reach, and the maximal length of the frog jump.
The second line contains a string s of length n, consisting of zeros and ones. If a character of the string s equals to zero, then in the corresponding point there is no lily flower. In the other case, in the corresponding point there is a lily flower. Guaranteed that the first and the last characters of the string s equal to one.
Output
If the frog can not reach the home, print -1.
In the other case, print the minimal number of jumps that the frog needs to reach the home which is in the point n from the point 1.
Examples
Input
8 4
10010101
Output
2
Input
4 2
1001
Output
-1
Input
8 4
11100101
Output
3
Input
12 3
101111100101
Output
4
Note
In the first example the from can reach home in two jumps: the first jump from the point 1 to the point 4 (the length of the jump is three), and the second jump from the point 4 to the point 8 (the length of the jump is four).
In the second example the frog can not reach home, because to make it she need to jump on a distance three, but the maximum length of her jump equals to two. | n,d =map(int,input().split())
string =input()
def f(arr,num):
#print (arr)
if (arr == '1'):
print (num)
quit()
for i in range(d,0,-1):
if (i>len(arr)-1):
continue
#print (i)
if (arr[i] != '0'):
f(arr[i:],num+1)
break
f(string,0)
print ('-1') | {
"input": [
"8 4\n11100101\n",
"8 4\n10010101\n",
"12 3\n101111100101\n",
"4 2\n1001\n"
],
"output": [
"3\n",
"2\n",
"4\n",
"-1\n"
]
} |
4,763 | 9 | For a permutation P[1... N] of integers from 1 to N, function f is defined as follows:
<image>
Let g(i) be the minimum positive integer j such that f(i, j) = i. We can show such j always exists.
For given N, A, B, find a permutation P of integers from 1 to N such that for 1 β€ i β€ N, g(i) equals either A or B.
Input
The only line contains three integers N, A, B (1 β€ N β€ 106, 1 β€ A, B β€ N).
Output
If no such permutation exists, output -1. Otherwise, output a permutation of integers from 1 to N.
Examples
Input
9 2 5
Output
6 5 8 3 4 1 9 2 7
Input
3 2 1
Output
1 2 3
Note
In the first example, g(1) = g(6) = g(7) = g(9) = 2 and g(2) = g(3) = g(4) = g(5) = g(8) = 5
In the second example, g(1) = g(2) = g(3) = 1 | n, a, b = map(int, input().split())
r = []
def f(a, l, r=r):
r += [a + l - 1] + list(range(a, a + l - 1))
i = 1
while n > 0:
if n % b is 0:
break
f(i, a)
i += a
n -= a
while n > 0:
f(i, b)
i += b
n -= b
print(-1) if n else print(*r)
| {
"input": [
"9 2 5\n",
"3 2 1\n"
],
"output": [
"2 1 4 3 6 7 8 9 5 ",
"1 2 3 "
]
} |
4,764 | 10 | Mahmoud has an array a consisting of n integers. He asked Ehab to find another array b of the same length such that:
* b is lexicographically greater than or equal to a.
* bi β₯ 2.
* b is pairwise coprime: for every 1 β€ i < j β€ n, bi and bj are coprime, i. e. GCD(bi, bj) = 1, where GCD(w, z) is the greatest common divisor of w and z.
Ehab wants to choose a special array so he wants the lexicographically minimal array between all the variants. Can you find it?
An array x is lexicographically greater than an array y if there exists an index i such than xi > yi and xj = yj for all 1 β€ j < i. An array x is equal to an array y if xi = yi for all 1 β€ i β€ n.
Input
The first line contains an integer n (1 β€ n β€ 105), the number of elements in a and b.
The second line contains n integers a1, a2, ..., an (2 β€ ai β€ 105), the elements of a.
Output
Output n space-separated integers, the i-th of them representing bi.
Examples
Input
5
2 3 5 4 13
Output
2 3 5 7 11
Input
3
10 3 7
Output
10 3 7
Note
Note that in the second sample, the array is already pairwise coprime so we printed it. | MAX_NUM = 2000000
prime_str = ('2 3 5 7 11 13 17 19 23 29 '
+ '31 37 41 43 47 53 59 61 67 71 '
+ '73 79 83 89 97 101 103 107 109 113 '
+ '127 131 137 139 149 151 157 163 167 173 '
+ '179 181 191 193 197 199 211 223 227 229 '
+ '233 239 241 251 257 263 269 271 277 281 '
+ '283 293 307 311 313 317 '
)
prime_list = [int(p) for p in prime_str.split()]
used = [False] * MAX_NUM
n = int(input())
a = list(map(int, input().split()))
def record(x):
t = []
for p in prime_list:
if x % p == 0:
while x % p == 0:
x = x // p
t.append(p)
if x == 1:
break
if x != 1:
t.append(x)
for ti in t:
for i in range(ti, MAX_NUM, ti):
used[i] = True
b = []
for ai in a:
if not used[ai]:
b.append(ai)
record(ai)
else:
temp = ai + 1
while used[temp]:
temp += 1
b.append(temp)
record(temp)
break
temp = 2
while len(b) < len(a):
while used[temp]:
temp += 1
b.append(temp)
record(temp)
print(' '.join(str(x) for x in b))
| {
"input": [
"5\n2 3 5 4 13\n",
"3\n10 3 7\n"
],
"output": [
"2 3 5 7 11 ",
"10 3 7 "
]
} |
4,765 | 8 | Petr likes to come up with problems about randomly generated data. This time problem is about random permutation. He decided to generate a random permutation this way: he takes identity permutation of numbers from 1 to n and then 3n times takes a random pair of different elements and swaps them. Alex envies Petr and tries to imitate him in all kind of things. Alex has also come up with a problem about random permutation. He generates a random permutation just like Petr but swaps elements 7n+1 times instead of 3n times. Because it is more random, OK?!
You somehow get a test from one of these problems and now you want to know from which one.
Input
In the first line of input there is one integer n (10^{3} β€ n β€ 10^{6}).
In the second line there are n distinct integers between 1 and n β the permutation of size n from the test.
It is guaranteed that all tests except for sample are generated this way: First we choose n β the size of the permutation. Then we randomly choose a method to generate a permutation β the one of Petr or the one of Alex. Then we generate a permutation using chosen method.
Output
If the test is generated via Petr's method print "Petr" (without quotes). If the test is generated via Alex's method print "Um_nik" (without quotes).
Example
Input
5
2 4 5 1 3
Output
Petr
Note
Please note that the sample is not a valid test (because of limitations for n) and is given only to illustrate input/output format. Your program still has to print correct answer to this test to get AC.
Due to randomness of input hacks in this problem are forbidden. | def main():
n = int(input())
if (n == 5):
print("Petr")
return
a = list(map(int, input().split()))
count = 0
for i in range(n):
if (a[i] == i + 1):
count += 1
if (count < (n // 1000)):
print("Um_nik")
else:
print("Petr")
main() | {
"input": [
"5\n2 4 5 1 3\n"
],
"output": [
"Petr\n"
]
} |
4,766 | 7 | You are given a set of 2n+1 integer points on a Cartesian plane. Points are numbered from 0 to 2n inclusive. Let P_i be the i-th point. The x-coordinate of the point P_i equals i. The y-coordinate of the point P_i equals zero (initially). Thus, initially P_i=(i,0).
The given points are vertices of a plot of a piecewise function. The j-th piece of the function is the segment P_{j}P_{j + 1}.
In one move you can increase the y-coordinate of any point with odd x-coordinate (i.e. such points are P_1, P_3, ..., P_{2n-1}) by 1. Note that the corresponding segments also change.
For example, the following plot shows a function for n=3 (i.e. number of points is 2β
3+1=7) in which we increased the y-coordinate of the point P_1 three times and y-coordinate of the point P_5 one time:
<image>
Let the area of the plot be the area below this plot and above the coordinate axis OX. For example, the area of the plot on the picture above is 4 (the light blue area on the picture above is the area of the plot drawn on it).
Let the height of the plot be the maximum y-coordinate among all initial points in the plot (i.e. points P_0, P_1, ..., P_{2n}). The height of the plot on the picture above is 3.
Your problem is to say which minimum possible height can have the plot consisting of 2n+1 vertices and having an area equal to k. Note that it is unnecessary to minimize the number of moves.
It is easy to see that any answer which can be obtained by performing moves described above always exists and is an integer number not exceeding 10^{18}.
Input
The first line of the input contains two integers n and k (1 β€ n, k β€ 10^{18}) β the number of vertices in a plot of a piecewise function and the area we need to obtain.
Output
Print one integer β the minimum possible height of a plot consisting of 2n+1 vertices and with an area equals k. It is easy to see that any answer which can be obtained by performing moves described above always exists and is an integer number not exceeding 10^{18}.
Examples
Input
4 3
Output
1
Input
4 12
Output
3
Input
999999999999999999 999999999999999986
Output
1
Note
One of the possible answers to the first example:
<image>
The area of this plot is 3, the height of this plot is 1.
There is only one possible answer to the second example:
<image>
The area of this plot is 12, the height of this plot is 3. | def f():
n,k = list(map(lambda x: int(x), input().split(' ')))
print((k+n-1)//n)
f()
| {
"input": [
"4 3\n",
"999999999999999999 999999999999999986\n",
"4 12\n"
],
"output": [
"1\n",
"1\n",
"3\n"
]
} |
4,767 | 9 | There are n candy boxes in front of Tania. The boxes are arranged in a row from left to right, numbered from 1 to n. The i-th box contains r_i candies, candies have the color c_i (the color can take one of three values βββ red, green, or blue). All candies inside a single box have the same color (and it is equal to c_i).
Initially, Tanya is next to the box number s. Tanya can move to the neighbor box (that is, with a number that differs by one) or eat candies in the current box. Tanya eats candies instantly, but the movement takes one second.
If Tanya eats candies from the box, then the box itself remains in place, but there is no more candies in it. In other words, Tanya always eats all the candies from the box and candies in the boxes are not refilled.
It is known that Tanya cannot eat candies of the same color one after another (that is, the colors of candies in two consecutive boxes from which she eats candies are always different). In addition, Tanya's appetite is constantly growing, so in each next box from which she eats candies, there should be strictly more candies than in the previous one.
Note that for the first box from which Tanya will eat candies, there are no restrictions on the color and number of candies.
Tanya wants to eat at least k candies. What is the minimum number of seconds she will need? Remember that she eats candies instantly, and time is spent only on movements.
Input
The first line contains three integers n, s and k (1 β€ n β€ 50, 1 β€ s β€ n, 1 β€ k β€ 2000) β number of the boxes, initial position of Tanya and lower bound on number of candies to eat. The following line contains n integers r_i (1 β€ r_i β€ 50) β numbers of candies in the boxes. The third line contains sequence of n letters 'R', 'G' and 'B', meaning the colors of candies in the correspondent boxes ('R' for red, 'G' for green, 'B' for blue). Recall that each box contains candies of only one color. The third line contains no spaces.
Output
Print minimal number of seconds to eat at least k candies. If solution doesn't exist, print "-1".
Examples
Input
5 3 10
1 2 3 4 5
RGBRR
Output
4
Input
2 1 15
5 6
RG
Output
-1
Note
The sequence of actions of Tanya for the first example:
* move from the box 3 to the box 2;
* eat candies from the box 2;
* move from the box 2 to the box 3;
* eat candy from the box 3;
* move from the box 3 to the box 4;
* move from the box 4 to the box 5;
* eat candies from the box 5.
Since Tanya eats candy instantly, the required time is four seconds. | n, s, k = map(int, input().split())
s -= 1
r = list(map(int, input().split()))
INF = float("inf")
c = input()
dp = [[] for i in range(n)]
def calc(u):
if dp[u]:
return
dp[u] = [0] * (r[u] + 1) + [INF] * (k - r[u])
for i in range(n):
if c[u] != c[i] and r[i] > r[u]:
calc(i)
d = abs(u - i)
for j in range(r[u] + 1, k + 1):
dp[u][j] = min(dp[u][j], dp[i][j - r[u]] + d)
ans = INF
for i in range(n):
calc(i)
ans = min(ans, abs(i - s) + dp[i][k])
if ans == INF:
print(-1)
else:
print(ans) | {
"input": [
"2 1 15\n5 6\nRG\n",
"5 3 10\n1 2 3 4 5\nRGBRR\n"
],
"output": [
"-1\n",
"4\n"
]
} |
4,768 | 8 | Little girl Margarita is a big fan of competitive programming. She especially loves problems about arrays and queries on them.
Recently, she was presented with an array a of the size of 10^9 elements that is filled as follows:
* a_1 = -1
* a_2 = 2
* a_3 = -3
* a_4 = 4
* a_5 = -5
* And so on ...
That is, the value of the i-th element of the array a is calculated using the formula a_i = i β
(-1)^i.
She immediately came up with q queries on this array. Each query is described with two numbers: l and r. The answer to a query is the sum of all the elements of the array at positions from l to r inclusive.
Margarita really wants to know the answer to each of the requests. She doesn't want to count all this manually, but unfortunately, she couldn't write the program that solves the problem either. She has turned to you β the best programmer.
Help her find the answers!
Input
The first line contains a single integer q (1 β€ q β€ 10^3) β the number of the queries.
Each of the next q lines contains two integers l and r (1 β€ l β€ r β€ 10^9) β the descriptions of the queries.
Output
Print q lines, each containing one number β the answer to the query.
Example
Input
5
1 3
2 5
5 5
4 4
2 3
Output
-2
-2
-5
4
-1
Note
In the first query, you need to find the sum of the elements of the array from position 1 to position 3. The sum is equal to a_1 + a_2 + a_3 = -1 + 2 -3 = -2.
In the second query, you need to find the sum of the elements of the array from position 2 to position 5. The sum is equal to a_2 + a_3 + a_4 + a_5 = 2 -3 + 4 - 5 = -2.
In the third query, you need to find the sum of the elements of the array from position 5 to position 5. The sum is equal to a_5 = -5.
In the fourth query, you need to find the sum of the elements of the array from position 4 to position 4. The sum is equal to a_4 = 4.
In the fifth query, you need to find the sum of the elements of the array from position 2 to position 3. The sum is equal to a_2 + a_3 = 2 - 3 = -1. | def f(n) :
return (n+1)//2 * ((-1)**(n%2))
q = int(input())
for i in range(0, q) :
a, b = map(int, input().split())
print(f(b)-f(a-1)) | {
"input": [
"5\n1 3\n2 5\n5 5\n4 4\n2 3\n"
],
"output": [
"-2\n-2\n-5\n4\n-1\n"
]
} |
4,769 | 7 | Tom is interested in power consumption of his favourite laptop. His laptop has three modes. In normal mode laptop consumes P1 watt per minute. T1 minutes after Tom moved the mouse or touched the keyboard for the last time, a screensaver starts and power consumption changes to P2 watt per minute. Finally, after T2 minutes from the start of the screensaver, laptop switches to the "sleep" mode and consumes P3 watt per minute. If Tom moves the mouse or touches the keyboard when the laptop is in the second or in the third mode, it switches to the first (normal) mode. Tom's work with the laptop can be divided into n time periods [l1, r1], [l2, r2], ..., [ln, rn]. During each interval Tom continuously moves the mouse and presses buttons on the keyboard. Between the periods Tom stays away from the laptop. Find out the total amount of power consumed by the laptop during the period [l1, rn].
Input
The first line contains 6 integer numbers n, P1, P2, P3, T1, T2 (1 β€ n β€ 100, 0 β€ P1, P2, P3 β€ 100, 1 β€ T1, T2 β€ 60). The following n lines contain description of Tom's work. Each i-th of these lines contains two space-separated integers li and ri (0 β€ li < ri β€ 1440, ri < li + 1 for i < n), which stand for the start and the end of the i-th period of work.
Output
Output the answer to the problem.
Examples
Input
1 3 2 1 5 10
0 10
Output
30
Input
2 8 4 2 5 10
20 30
50 100
Output
570 | def f(w, w1, w2):
r1 = min(w, w1)
r3 = max(0, w - w1 - w2)
return r1, w - r1 - r3, r3
n, p1, p2, p3, t1, t2 = [int(i) for i in input().split()]
s = 0
a = [[int(j) for j in input().split()] for i in range(n)]
for i in [(f(a[i + 1][0] - a[i][1], t1, t2)) for i in range(len(a) - 1)]:
s += i[0] * p1 + i[1] * p2 + i[2] * p3
print(s + sum([x[1] - x[0] for x in a]) * p1)
| {
"input": [
"2 8 4 2 5 10\n20 30\n50 100\n",
"1 3 2 1 5 10\n0 10\n"
],
"output": [
"570\n",
"30\n"
]
} |
4,770 | 8 | Arkady bought an air ticket from a city A to a city C. Unfortunately, there are no direct flights, but there are a lot of flights from A to a city B, and from B to C.
There are n flights from A to B, they depart at time moments a_1, a_2, a_3, ..., a_n and arrive at B t_a moments later.
There are m flights from B to C, they depart at time moments b_1, b_2, b_3, ..., b_m and arrive at C t_b moments later.
The connection time is negligible, so one can use the i-th flight from A to B and the j-th flight from B to C if and only if b_j β₯ a_i + t_a.
You can cancel at most k flights. If you cancel a flight, Arkady can not use it.
Arkady wants to be in C as early as possible, while you want him to be in C as late as possible. Find the earliest time Arkady can arrive at C, if you optimally cancel k flights. If you can cancel k or less flights in such a way that it is not possible to reach C at all, print -1.
Input
The first line contains five integers n, m, t_a, t_b and k (1 β€ n, m β€ 2 β
10^5, 1 β€ k β€ n + m, 1 β€ t_a, t_b β€ 10^9) β the number of flights from A to B, the number of flights from B to C, the flight time from A to B, the flight time from B to C and the number of flights you can cancel, respectively.
The second line contains n distinct integers in increasing order a_1, a_2, a_3, ..., a_n (1 β€ a_1 < a_2 < β¦ < a_n β€ 10^9) β the times the flights from A to B depart.
The third line contains m distinct integers in increasing order b_1, b_2, b_3, ..., b_m (1 β€ b_1 < b_2 < β¦ < b_m β€ 10^9) β the times the flights from B to C depart.
Output
If you can cancel k or less flights in such a way that it is not possible to reach C at all, print -1.
Otherwise print the earliest time Arkady can arrive at C if you cancel k flights in such a way that maximizes this time.
Examples
Input
4 5 1 1 2
1 3 5 7
1 2 3 9 10
Output
11
Input
2 2 4 4 2
1 10
10 20
Output
-1
Input
4 3 2 3 1
1 999999998 999999999 1000000000
3 4 1000000000
Output
1000000003
Note
Consider the first example. The flights from A to B depart at time moments 1, 3, 5, and 7 and arrive at B at time moments 2, 4, 6, 8, respectively. The flights from B to C depart at time moments 1, 2, 3, 9, and 10 and arrive at C at time moments 2, 3, 4, 10, 11, respectively. You can cancel at most two flights. The optimal solution is to cancel the first flight from A to B and the fourth flight from B to C. This way Arkady has to take the second flight from A to B, arrive at B at time moment 4, and take the last flight from B to C arriving at C at time moment 11.
In the second example you can simply cancel all flights from A to B and you're done.
In the third example you can cancel only one flight, and the optimal solution is to cancel the first flight from A to B. Note that there is still just enough time to catch the last flight from B to C. | import sys
def LI(): return list(map(int, sys.stdin.readline().split()))
def main():
n,m,ta,tb,k=LI()
A = LI()
B = LI()
if k>=n or k>=m:
return -1
maxt = 0
j = 0
for i in range(k+1):
c = A[i] + ta
while j < m and c > B[j]:
j += 1
if j + k - i>=m:
return -1
maxt = max(B[j + k - i]+tb, maxt)
return maxt
print(main()) | {
"input": [
"2 2 4 4 2\n1 10\n10 20\n",
"4 5 1 1 2\n1 3 5 7\n1 2 3 9 10\n",
"4 3 2 3 1\n1 999999998 999999999 1000000000\n3 4 1000000000\n"
],
"output": [
"-1\n",
"11\n",
"1000000003\n"
]
} |
4,771 | 10 | Toad Rash has a binary string s. A binary string consists only of zeros and ones.
Let n be the length of s.
Rash needs to find the number of such pairs of integers l, r that 1 β€ l β€ r β€ n and there is at least one pair of integers x, k such that 1 β€ x, k β€ n, l β€ x < x + 2k β€ r, and s_x = s_{x+k} = s_{x+2k}.
Find this number of pairs for Rash.
Input
The first line contains the string s (1 β€ |s| β€ 300 000), consisting of zeros and ones.
Output
Output one integer: the number of such pairs of integers l, r that 1 β€ l β€ r β€ n and there is at least one pair of integers x, k such that 1 β€ x, k β€ n, l β€ x < x + 2k β€ r, and s_x = s_{x+k} = s_{x+2k}.
Examples
Input
010101
Output
3
Input
11001100
Output
0
Note
In the first example, there are three l, r pairs we need to count: 1, 6; 2, 6; and 1, 5.
In the second example, there are no values x, k for the initial string, so the answer is 0. | s=input()
def pri(l,r):
k=1
while r-2*k>=l:
if s[r]!=s[r-k] or s[r-k]!=s[r-2*k]:
k+=1
continue
return False
return True
ans=0
for i in range(len(s)):
j=i
while j<len(s) and pri(i,j):
j+=1
ans+=len(s)-j
print(ans)
| {
"input": [
"010101\n",
"11001100\n"
],
"output": [
"3\n",
"0\n"
]
} |
4,772 | 12 | Let x be an array of integers x = [x_1, x_2, ..., x_n]. Let's define B(x) as a minimal size of a partition of x into subsegments such that all elements in each subsegment are equal. For example, B([3, 3, 6, 1, 6, 6, 6]) = 4 using next partition: [3, 3\ |\ 6\ |\ 1\ |\ 6, 6, 6].
Now you don't have any exact values of x, but you know that x_i can be any integer value from [l_i, r_i] (l_i β€ r_i) uniformly at random. All x_i are independent.
Calculate expected value of (B(x))^2, or E((B(x))^2). It's guaranteed that the expected value can be represented as rational fraction P/Q where (P, Q) = 1, so print the value P β
Q^{-1} mod 10^9 + 7.
Input
The first line contains the single integer n (1 β€ n β€ 2 β
10^5) β the size of the array x.
The second line contains n integers l_1, l_2, ..., l_n (1 β€ l_i β€ 10^9).
The third line contains n integers r_1, r_2, ..., r_n (l_i β€ r_i β€ 10^9).
Output
Print the single integer β E((B(x))^2) as P β
Q^{-1} mod 10^9 + 7.
Examples
Input
3
1 1 1
1 2 3
Output
166666673
Input
3
3 4 5
4 5 6
Output
500000010
Note
Let's describe all possible values of x for the first sample:
* [1, 1, 1]: B(x) = 1, B^2(x) = 1;
* [1, 1, 2]: B(x) = 2, B^2(x) = 4;
* [1, 1, 3]: B(x) = 2, B^2(x) = 4;
* [1, 2, 1]: B(x) = 3, B^2(x) = 9;
* [1, 2, 2]: B(x) = 2, B^2(x) = 4;
* [1, 2, 3]: B(x) = 3, B^2(x) = 9;
So E = 1/6 (1 + 4 + 4 + 9 + 4 + 9) = 31/6 or 31 β
6^{-1} = 166666673.
All possible values of x for the second sample:
* [3, 4, 5]: B(x) = 3, B^2(x) = 9;
* [3, 4, 6]: B(x) = 3, B^2(x) = 9;
* [3, 5, 5]: B(x) = 2, B^2(x) = 4;
* [3, 5, 6]: B(x) = 3, B^2(x) = 9;
* [4, 4, 5]: B(x) = 2, B^2(x) = 4;
* [4, 4, 6]: B(x) = 2, B^2(x) = 4;
* [4, 5, 5]: B(x) = 2, B^2(x) = 4;
* [4, 5, 6]: B(x) = 3, B^2(x) = 9;
So E = 1/8 (9 + 9 + 4 + 9 + 4 + 4 + 4 + 9) = 52/8 or 13 β
2^{-1} = 500000010. | N = int(input())
mod = 10**9 + 7
L = list(map(int, input().split()))
R = list(map(int, input().split()))
def calb2(x):
ran = (R[x] - L[x] + 1) * (R[x+1] - L[x+1] + 1) % mod
return max(0, min(R[x], R[x+1]) - max(L[x], L[x+1]) + 1) * pow(ran, mod-2, mod) % mod
def calb3(x, b2):
ran = (R[x] - L[x] + 1) * (R[x+1] - L[x+1] + 1) * (R[x+2] - L[x+2] + 1) % mod
return max(0, min(R[x], R[x+1], R[x+2]) - max(L[x], L[x+1], L[x+2]) + 1) * pow(ran, mod-2, mod) % mod
def solve():
if N == 1:
return 1
b2 = [calb2(i) for i in range(N-1)]
b3 = [calb3(i, b2) for i in range(N-2)]
res = N**2 % mod
for b in b3:
res = (res + 2*b) % mod
acb2 = [0]*(N-1)
acb2[0] = b2[0]
for i in range(1, N-1):
acb2[i] = (b2[i] + acb2[i-1]) % mod
res = (res - (2*N - 1) *acb2[-1]) % mod
for i in range(2, N-1):
res = (res + 2*b2[i]*acb2[i-2]) % mod
return res
print(solve())
| {
"input": [
"3\n1 1 1\n1 2 3\n",
"3\n3 4 5\n4 5 6\n"
],
"output": [
"166666673\n",
"500000010\n"
]
} |
4,773 | 11 | This is an interactive problem
You are given a grid nΓ n, where n is odd. Rows are enumerated from 1 to n from up to down, columns are enumerated from 1 to n from left to right. Cell, standing on the intersection of row x and column y, is denoted by (x, y).
Every cell contains 0 or 1. It is known that the top-left cell contains 1, and the bottom-right cell contains 0.
We want to know numbers in all cells of the grid. To do so we can ask the following questions:
"? x_1 y_1 x_2 y_2", where 1 β€ x_1 β€ x_2 β€ n, 1 β€ y_1 β€ y_2 β€ n, and x_1 + y_1 + 2 β€ x_2 + y_2. In other words, we output two different cells (x_1, y_1), (x_2, y_2) of the grid such that we can get from the first to the second by moving only to the right and down, and they aren't adjacent.
As a response to such question you will be told if there exists a path between (x_1, y_1) and (x_2, y_2), going only to the right or down, numbers in cells of which form a palindrome.
For example, paths, shown in green, are palindromic, so answer for "? 1 1 2 3" and "? 1 2 3 3" would be that there exists such path. However, there is no palindromic path between (1, 1) and (3, 1).
<image>
Determine all cells of the grid by asking not more than n^2 questions. It can be shown that the answer always exists.
Input
The first line contains odd integer (3 β€ n < 50) β the side of the grid.
Interaction
You begin the interaction by reading n.
To ask a question about cells (x_1, y_1), (x_2, y_2), in a separate line output "? x_1 y_1 x_2 y_2".
Numbers in the query have to satisfy 1 β€ x_1 β€ x_2 β€ n, 1 β€ y_1 β€ y_2 β€ n, and x_1 + y_1 + 2 β€ x_2 + y_2. Don't forget to 'flush', to get the answer.
In response, you will receive 1, if there exists a path going from (x_1, y_1) to (x_2, y_2) only to the right or down, numbers in cells of which form a palindrome, and 0 otherwise.
In case your query is invalid or you asked more than n^2 queries, program will print -1 and will finish interaction. You will receive Wrong answer verdict. Make sure to exit immediately to avoid getting other verdicts.
When you determine numbers in all cells, output "!".
Then output n lines, the i-th of which is a string of length n, corresponding to numbers in the i-th row of the grid.
After printing a query do not forget to output end of line and flush the output. Otherwise, you will get Idleness limit exceeded. To do this, use:
* fflush(stdout) or cout.flush() in C++;
* System.out.flush() in Java;
* flush(output) in Pascal;
* stdout.flush() in Python;
* see documentation for other languages.
Hack Format
To hack, use the following format.
The first line should contain a single odd integer n (side of your grid).
The i-th of n following lines should contain a string of length n corresponding to the i-th row of the grid. Top left element of the grid has to be equal to 1, bottom right has to be equal to 0.
Example
Input
3
0
1
0
1
1
1
1
Output
? 1 1 1 3
? 1 1 2 3
? 2 1 2 3
? 3 1 3 3
? 2 2 3 3
? 1 2 3 2
? 1 2 3 3
!
100
001
000 | from sys import stdout
# matrix="""
# 101110111011101110111
# 011101110111011101110
# 111011101110111011101
# 110111011101110111011
# 101110111011101110111
# 011101110111011101110
# 111011101110111011101
# 110111011101110111011
# 101110111011101110111
# 011101110111011101110
# 111011101110111011100
# 110111011101110111001
# 101110111011101110010
# 011101110111011100100
# 111011101110111001000
# 110111011101110010001
# 101110111011100100010
# 011101110111001000100
# 111011101110010001000
# 110111011100100010001
# 101110111001000100010"""
#m=matrix.split()
n=int(input())#len(m)#
def query(i,j,k,l):
print("? {} {} {} {}".format(i,j,k,l))
if (k+l-i-j)==2:
res=1 if m[i-1][j-1]==m[k-1][l-1] else 0
if (k+l-i-j)==3:#la forme doit etre rect
assert k>i and l>j
isok=(a[i-1][j-1]==a[k-1][l-1])
if isok:
lautre= (m[k-2][j-1]==m[k-1][j-1]) if (k-i==2) else (m[i-1][l-1]==m[i-1][l-2])
matchpal= (m[i][j-1]==m[i][j]) or (m[i-1][j]==m[i][j]) or lautre
isok&=matchpal
res=1 if isok else 0
print(res)
return res
def req(i,j,k,l):
print("? {} {} {} {}".format(i,j,k,l))
stdout.flush()
rep=int(input())
return rep
a=[[0 for i in range(n)] for j in range(n)]
a[0][0]=1
a[n-1][n-1]=-1
a[0][1]=2
#a[2][1]
prev=0,1
i=2
j=1
rep=req(prev[0]+1,prev[1]+1,i+1,j+1)
if rep:
a[i][j]=a[prev[0]][prev[1]]
else:
a[i][j]=-a[prev[0]][prev[1]]
#a[1][0]
prev=2,1
i=1
j=0
rep=req(i+1,j+1,prev[0]+1,prev[1]+1)
if rep:
a[i][j]=a[prev[0]][prev[1]]
else:
a[i][j]=-a[prev[0]][prev[1]]
#on fait le reste
for i in range(n):
for j in range(n):
if not a[i][j]:
prev=(i-1,j-1) if i and j else ((i-2,j) if i else (i,j-2))
rep=req(prev[0]+1,prev[1]+1,i+1,j+1)
if rep:
a[i][j]=a[prev[0]][prev[1]]
else:
a[i][j]=-a[prev[0]][prev[1]]
assert(a[i][j])
#on cherche une case paire tq case +2 +2 est diffΓ©rente
baserec=-1,-1
for i in range(n-2):
for j in range(n-2):
if (i+j+1)%2 and a[i][j]!=a[i+2][j+2]:
baserec=i,j
break
if baserec[0]!=-1:
break
assert baserec[0]!=-1
i,j=baserec
#print("baserec",i,j)
rv2=None
#print(a[i][j],a[i][j+1],a[i][j+2])
#print(a[i+1][j],a[i+1][j+1],a[i+1][j+2])
#print(a[i+2][j],a[i+2][j+1],a[i+2][j+2])
if a[i][j+1]==a[i+1][j+2]:
if a[i+1][j+1]==a[i][j]:
prev=i,j
curr=i+1,j+2
rep=req(prev[0]+1,prev[1]+1,curr[0]+1,curr[1]+1)
if rep:
rv2=a[i][j] if a[i][j+1]==2 else -a[i][j]
else:
rv2=-a[i][j] if a[i][j+1]==2 else a[i][j]
else:
prev=i,j+1
curr=i+2,j+2
rep=req(prev[0]+1,prev[1]+1,curr[0]+1,curr[1]+1)
if rep:
rv2=a[i+1][j+1] if a[i][j+1]==2 else -a[i+1][j+1]
else:
rv2=-a[i+1][j+1] if a[i][j+1]==2 else a[i+1][j+1]
else:
if a[i+1][j+1]!=a[i][j]:
prev=i,j
curr=i+1,j+2
rep=req(prev[0]+1,prev[1]+1,curr[0]+1,curr[1]+1)
if rep:
rv2=a[i+1][j+1] if a[i][j+1]==2 else -a[i+1][j+1]
else:
rv2=-a[i+1][j+1] if a[i][j+1]==2 else a[i+1][j+1]
else:
prev=i,j+1
curr=i+2,j+2
rep=req(prev[0]+1,prev[1]+1,curr[0]+1,curr[1]+1)
if rep:
rv2=a[i+1][j+1] if a[i+1][j+2]==2 else -a[i+1][j+1]
else:
rv2=-a[i+1][j+1] if a[i+1][j+2]==2 else a[i+1][j+1]
for i in range(n):
for j in range(n):
if a[i][j] in (-2,2):
a[i][j]= rv2 if a[i][j]==2 else -rv2
print("!")
for i in range(n):
r=""
for j in range(n):
r+="1" if a[i][j]>0 else "0"
print(r)
stdout.flush() | {
"input": [
"3\n0\n1\n0\n1\n1\n1\n1"
],
"output": [
"\n? 1 1 1 3\n? 1 1 2 3\n? 2 1 2 3\n? 3 1 3 3\n? 2 2 3 3\n? 1 2 3 2\n? 1 2 3 3\n!\n100\n001\n000"
]
} |
4,774 | 7 | Kolya is very absent-minded. Today his math teacher asked him to solve a simple problem with the equation a + 1 = b with positive integers a and b, but Kolya forgot the numbers a and b. He does, however, remember that the first (leftmost) digit of a was d_a, and the first (leftmost) digit of b was d_b.
Can you reconstruct any equation a + 1 = b that satisfies this property? It may be possible that Kolya misremembers the digits, and there is no suitable equation, in which case report so.
Input
The only line contains two space-separated digits d_a and d_b (1 β€ d_a, d_b β€ 9).
Output
If there is no equation a + 1 = b with positive integers a and b such that the first digit of a is d_a, and the first digit of b is d_b, print a single number -1.
Otherwise, print any suitable a and b that both are positive and do not exceed 10^9. It is guaranteed that if a solution exists, there also exists a solution with both numbers not exceeding 10^9.
Examples
Input
1 2
Output
199 200
Input
4 4
Output
412 413
Input
5 7
Output
-1
Input
6 2
Output
-1 | def solve(a,b):
for c in range(10):
d = a+str(c)
e = str(int(d)+1)
if e[0] == b:
return d,e
return [-1]
a,b = input().split()
print(*solve(a,b)) | {
"input": [
"1 2\n",
"5 7\n",
"6 2\n",
"4 4\n"
],
"output": [
"19 20",
"-1\n",
"-1\n",
"40 41\n"
]
} |
4,775 | 9 | The only difference between easy and hard versions is the maximum value of n.
You are given a positive integer number n. You really love good numbers so you want to find the smallest good number greater than or equal to n.
The positive integer is called good if it can be represented as a sum of distinct powers of 3 (i.e. no duplicates of powers of 3 are allowed).
For example:
* 30 is a good number: 30 = 3^3 + 3^1,
* 1 is a good number: 1 = 3^0,
* 12 is a good number: 12 = 3^2 + 3^1,
* but 2 is not a good number: you can't represent it as a sum of distinct powers of 3 (2 = 3^0 + 3^0),
* 19 is not a good number: you can't represent it as a sum of distinct powers of 3 (for example, the representations 19 = 3^2 + 3^2 + 3^0 = 3^2 + 3^1 + 3^1 + 3^1 + 3^0 are invalid),
* 20 is also not a good number: you can't represent it as a sum of distinct powers of 3 (for example, the representation 20 = 3^2 + 3^2 + 3^0 + 3^0 is invalid).
Note, that there exist other representations of 19 and 20 as sums of powers of 3 but none of them consists of distinct powers of 3.
For the given positive integer n find such smallest m (n β€ m) that m is a good number.
You have to answer q independent queries.
Input
The first line of the input contains one integer q (1 β€ q β€ 500) β the number of queries. Then q queries follow.
The only line of the query contains one integer n (1 β€ n β€ 10^{18}).
Output
For each query, print such smallest integer m (where n β€ m) that m is a good number.
Example
Input
8
1
2
6
13
14
3620
10000
1000000000000000000
Output
1
3
9
13
27
6561
19683
1350851717672992089 | def solve():
x = int(input())
s = 0
i = 0
while (s <= x):
s += 3 ** i
i += 1
i -= 1
while (i >= 0):
if (s - 3 ** i >= x):
s -= 3 ** i
i -= 1
return s
q = int(input())
print(*[solve() for i in range(q)], sep='\n') | {
"input": [
"8\n1\n2\n6\n13\n14\n3620\n10000\n1000000000000000000\n"
],
"output": [
"1\n3\n9\n13\n27\n6561\n19683\n1350851717672992089\n"
]
} |
4,776 | 7 | VK news recommendation system daily selects interesting publications of one of n disjoint categories for each user. Each publication belongs to exactly one category. For each category i batch algorithm selects a_i publications.
The latest A/B test suggests that users are reading recommended publications more actively if each category has a different number of publications within daily recommendations. The targeted algorithm can find a single interesting publication of i-th category within t_i seconds.
What is the minimum total time necessary to add publications to the result of batch algorithm execution, so all categories have a different number of publications? You can't remove publications recommended by the batch algorithm.
Input
The first line of input consists of single integer n β the number of news categories (1 β€ n β€ 200 000).
The second line of input consists of n integers a_i β the number of publications of i-th category selected by the batch algorithm (1 β€ a_i β€ 10^9).
The third line of input consists of n integers t_i β time it takes for targeted algorithm to find one new publication of category i (1 β€ t_i β€ 10^5).
Output
Print one integer β the minimal required time for the targeted algorithm to get rid of categories with the same size.
Examples
Input
5
3 7 9 7 8
5 2 5 7 5
Output
6
Input
5
1 2 3 4 5
1 1 1 1 1
Output
0
Note
In the first example, it is possible to find three publications of the second type, which will take 6 seconds.
In the second example, all news categories contain a different number of publications. | # from collections import defaultdict
# for _ in range(int(input())):
n = int(input())
a = list(map(int, input().split()))
ts = list(map(int, input().split()))
tt = [(ts[i], i) for i in range(n)]
tt.sort(reverse=True)
conflict = {}
next = {}
money = 0
def get_next(i):
if i not in conflict:
return i
if next[i] in conflict:
next[i] = get_next(next[i])
return next[i]
for tx in tt:
t, i = tx
nee = get_next(a[i])
money += (nee - a[i]) * t
conflict[nee] = True
next[nee] = nee+1
print(money)
| {
"input": [
"5\n1 2 3 4 5\n1 1 1 1 1\n",
"5\n3 7 9 7 8\n5 2 5 7 5\n"
],
"output": [
"0\n",
"6\n"
]
} |
4,777 | 12 | Eric is the teacher of graph theory class. Today, Eric teaches independent set and edge-induced subgraph.
Given a graph G=(V,E), an independent set is a subset of vertices V' β V such that for every pair u,v β V', (u,v) not β E (i.e. no edge in E connects two vertices from V').
An edge-induced subgraph consists of a subset of edges E' β E and all the vertices in the original graph that are incident on at least one edge in the subgraph.
Given E' β E, denote G[E'] the edge-induced subgraph such that E' is the edge set of the subgraph. Here is an illustration of those definitions:
<image>
In order to help his students get familiar with those definitions, he leaves the following problem as an exercise:
Given a tree G=(V,E), calculate the sum of w(H) over all except null edge-induced subgraph H of G, where w(H) is the number of independent sets in H. Formally, calculate β _{β
not= E' β E} w(G[E']).
Show Eric that you are smarter than his students by providing the correct answer as quickly as possible. Note that the answer might be large, you should output the answer modulo 998,244,353.
Input
The first line contains a single integer n (2 β€ n β€ 3 β
10^5), representing the number of vertices of the graph G.
Each of the following n-1 lines contains two integers u and v (1 β€ u,v β€ n, u not= v), describing edges of the given tree.
It is guaranteed that the given edges form a tree.
Output
Output one integer, representing the desired value modulo 998,244,353.
Examples
Input
2
2 1
Output
3
Input
3
1 2
3 2
Output
11
Note
For the second example, all independent sets are listed below.
<image> | import sys
readline = sys.stdin.readline
def parorder(Edge, p):
N = len(Edge)
par = [0]*N
par[p] = -1
stack = [p]
order = []
visited = set([p])
ast = stack.append
apo = order.append
while stack:
vn = stack.pop()
apo(vn)
for vf in Edge[vn]:
if vf in visited:
continue
visited.add(vf)
par[vf] = vn
ast(vf)
return par, order
def getcld(p):
res = [[] for _ in range(len(p))]
for i, v in enumerate(p[1:], 1):
res[v].append(i)
return res
N = int(readline())
MOD = 998244353
Edge = [[] for _ in range(N)]
for _ in range(N-1):
a, b = map(int, readline().split())
a -= 1
b -= 1
Edge[a].append(b)
Edge[b].append(a)
P, L = parorder(Edge, 0)
C = getcld(P)
dp = [[1, 1, 0, 0, 1] for _ in range(N)]
for p in L[::-1]:
if not C[p]:
continue
res = 1
res2 = 1
res3 = 1
for ci in C[p]:
res = (res*(dp[ci][2] + dp[ci][3] + dp[ci][4])) % MOD
res2 = (res2*(dp[ci][1] + dp[ci][2] + 2*dp[ci][3] + dp[ci][4])) % MOD
res3 = (res3*(sum(dp[ci]) + dp[ci][2] + dp[ci][3])) % MOD
dp[p][0] = res
dp[p][1] = res
dp[p][2] = (res2 - res)%MOD
dp[p][3] = (res3 - res)%MOD
dp[p][4] = res
print((dp[0][2] + dp[0][3] + dp[0][4] - 1) %MOD) | {
"input": [
"2\n2 1\n",
"3\n1 2\n3 2\n"
],
"output": [
"3\n",
"11\n"
]
} |
4,778 | 8 | You are given two arrays a and b both consisting of n positive (greater than zero) integers. You are also given an integer k.
In one move, you can choose two indices i and j (1 β€ i, j β€ n) and swap a_i and b_j (i.e. a_i becomes b_j and vice versa). Note that i and j can be equal or different (in particular, swap a_2 with b_2 or swap a_3 and b_9 both are acceptable moves).
Your task is to find the maximum possible sum you can obtain in the array a if you can do no more than (i.e. at most) k such moves (swaps).
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 β€ t β€ 200) β the number of test cases. Then t test cases follow.
The first line of the test case contains two integers n and k (1 β€ n β€ 30; 0 β€ k β€ n) β the number of elements in a and b and the maximum number of moves you can do. The second line of the test case contains n integers a_1, a_2, ..., a_n (1 β€ a_i β€ 30), where a_i is the i-th element of a. The third line of the test case contains n integers b_1, b_2, ..., b_n (1 β€ b_i β€ 30), where b_i is the i-th element of b.
Output
For each test case, print the answer β the maximum possible sum you can obtain in the array a if you can do no more than (i.e. at most) k swaps.
Example
Input
5
2 1
1 2
3 4
5 5
5 5 6 6 5
1 2 5 4 3
5 3
1 2 3 4 5
10 9 10 10 9
4 0
2 2 4 3
2 4 2 3
4 4
1 2 2 1
4 4 5 4
Output
6
27
39
11
17
Note
In the first test case of the example, you can swap a_1 = 1 and b_2 = 4, so a=[4, 2] and b=[3, 1].
In the second test case of the example, you don't need to swap anything.
In the third test case of the example, you can swap a_1 = 1 and b_1 = 10, a_3 = 3 and b_3 = 10 and a_2 = 2 and b_4 = 10, so a=[10, 10, 10, 4, 5] and b=[1, 9, 3, 2, 9].
In the fourth test case of the example, you cannot swap anything.
In the fifth test case of the example, you can swap arrays a and b, so a=[4, 4, 5, 4] and b=[1, 2, 2, 1]. | def read():return list(map(int,input().split()))
for i in range(int(input())):
n, k = read()
a = sorted(read())
b = sorted(read())
ans = sum(a[k:])
for i in range(k):
ans += max(a[i],b[~i])
print(ans)
| {
"input": [
"5\n2 1\n1 2\n3 4\n5 5\n5 5 6 6 5\n1 2 5 4 3\n5 3\n1 2 3 4 5\n10 9 10 10 9\n4 0\n2 2 4 3\n2 4 2 3\n4 4\n1 2 2 1\n4 4 5 4\n"
],
"output": [
"6\n27\n39\n11\n17\n"
]
} |
4,779 | 7 | There are two rival donut shops.
The first shop sells donuts at retail: each donut costs a dollars.
The second shop sells donuts only in bulk: box of b donuts costs c dollars. So if you want to buy x donuts from this shop, then you have to buy the smallest number of boxes such that the total number of donuts in them is greater or equal to x.
You want to determine two positive integer values:
1. how many donuts can you buy so that they are strictly cheaper in the first shop than in the second shop?
2. how many donuts can you buy so that they are strictly cheaper in the second shop than in the first shop?
If any of these values doesn't exist then that value should be equal to -1. If there are multiple possible answers, then print any of them.
The printed values should be less or equal to 10^9. It can be shown that under the given constraints such values always exist if any values exist at all.
Input
The first line contains a single integer t (1 β€ t β€ 1000) β the number of testcases.
Each of the next t lines contains three integers a, b and c (1 β€ a β€ 10^9, 2 β€ b β€ 10^9, 1 β€ c β€ 10^9).
Output
For each testcase print two positive integers. For both shops print such x that buying x donuts in this shop is strictly cheaper than buying x donuts in the other shop. x should be greater than 0 and less or equal to 10^9.
If there is no such x, then print -1. If there are multiple answers, then print any of them.
Example
Input
4
5 10 4
4 5 20
2 2 3
1000000000 1000000000 1000000000
Output
-1 20
8 -1
1 2
-1 1000000000
Note
In the first testcase buying any number of donuts will be cheaper in the second shop. For example, for 3 or 5 donuts you'll have to buy a box of 10 donuts for 4 dollars. 3 or 5 donuts in the first shop would cost you 15 or 25 dollars, respectively, however. For 20 donuts you'll have to buy two boxes for 8 dollars total. Note that 3 and 5 are also valid answers for the second shop, along with many other answers.
In the second testcase buying any number of donuts will be either cheaper in the first shop or the same price. 8 donuts cost 32 dollars in the first shop and 40 dollars in the second shop (because you have to buy two boxes). 10 donuts will cost 40 dollars in both shops, so 10 is not a valid answer for any of the shops.
In the third testcase 1 donut costs 2 and 3 dollars, respectively. 2 donuts cost 4 and 3 dollars. Thus, 1 is a valid answer for the first shop and 2 is a valid answer for the second shop.
In the fourth testcase 10^9 donuts cost 10^{18} dollars in the first shop and 10^9 dollars in the second shop. | def solve():
a, b, c = map(int, input().split())
ans1 = [1, -1][a >= c]
ans2 = [b, -1][a * b <= c]
print(ans1, ans2)
t = int(input())
for _ in range(t):
solve()
| {
"input": [
"4\n5 10 4\n4 5 20\n2 2 3\n1000000000 1000000000 1000000000\n"
],
"output": [
"-1 10\n1 -1\n1 2\n-1 1000000000\n"
]
} |
4,780 | 8 | So nearly half of the winter is over and Maria is dreaming about summer. She's fed up with skates and sleds, she was dreaming about Hopscotch all night long. It's a very popular children's game. The game field, the court, looks as is shown in the figure (all blocks are square and are numbered from bottom to top, blocks in the same row are numbered from left to right). Let us describe the hopscotch with numbers that denote the number of squares in the row, staring from the lowest one: 1-1-2-1-2-1-2-(1-2)..., where then the period is repeated (1-2).
<image>
The coordinate system is defined as shown in the figure. Side of all the squares are equal and have length a.
Maria is a very smart and clever girl, and she is concerned with quite serious issues: if she throws a stone into a point with coordinates (x, y), then will she hit some square? If the answer is positive, you are also required to determine the number of the square.
It is believed that the stone has fallen into the square if it is located strictly inside it. In other words a stone that has fallen on the square border is not considered a to hit a square.
Input
The only input line contains three integers: a, x, y, where a (1 β€ a β€ 100) is the side of the square, x and y ( - 106 β€ x β€ 106, 0 β€ y β€ 106) are coordinates of the stone.
Output
Print the number of the square, inside which the stone fell. If the stone is on a border of some stone or outside the court, print "-1" without the quotes.
Examples
Input
1 0 0
Output
-1
Input
3 1 1
Output
1
Input
3 0 10
Output
5
Input
3 0 7
Output
-1
Input
3 4 0
Output
-1 | def f(a,x,y):
if(x>=a or x<=0-a or y%a==0):
print(-1)
return
if(y<a):
if(x<a/2 and x+a/2>0):
print(1)
else:
print(-1)
return
y-=a
t=int(y/(a))
if(t%2==0):
if(x<a/2 and x+a/2>0):
print(int(2+t/2*3))
else:
print(-1)
return
else:
t-=1
val=int(2+t/2*3)
if(x==0 or x>a or x+a<0):
print(-1)
elif x>0:
print(val+2)
else:
print(val+1)
return
a,x,y=map(int,input().split())
f(a,x,y) | {
"input": [
"3 4 0\n",
"3 0 7\n",
"3 0 10\n",
"3 1 1\n",
"1 0 0\n"
],
"output": [
"-1\n",
"-1\n",
"5\n",
"1\n",
"-1\n"
]
} |
4,781 | 8 | You're given an array b of length n. Let's define another array a, also of length n, for which a_i = 2^{b_i} (1 β€ i β€ n).
Valerii says that every two non-intersecting subarrays of a have different sums of elements. You want to determine if he is wrong. More formally, you need to determine if there exist four integers l_1,r_1,l_2,r_2 that satisfy the following conditions:
* 1 β€ l_1 β€ r_1 < l_2 β€ r_2 β€ n;
* a_{l_1}+a_{l_1+1}+β¦+a_{r_1-1}+a_{r_1} = a_{l_2}+a_{l_2+1}+β¦+a_{r_2-1}+a_{r_2}.
If such four integers exist, you will prove Valerii wrong. Do they exist?
An array c is a subarray of an array d if c can be obtained from d by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 β€ t β€ 100). Description of the test cases follows.
The first line of every test case contains a single integer n (2 β€ n β€ 1000).
The second line of every test case contains n integers b_1,b_2,β¦,b_n (0 β€ b_i β€ 10^9).
Output
For every test case, if there exist two non-intersecting subarrays in a that have the same sum, output YES on a separate line. Otherwise, output NO on a separate line.
Also, note that each letter can be in any case.
Example
Input
2
6
4 3 0 1 2 0
2
2 5
Output
YES
NO
Note
In the first case, a = [16,8,1,2,4,1]. Choosing l_1 = 1, r_1 = 1, l_2 = 2 and r_2 = 6 works because 16 = (8+1+2+4+1).
In the second case, you can verify that there is no way to select to such subarrays. | def solve(arr,n):
return 'Yes' if len(arr)!= n else "No"
for _ in range(int(input())):
n = int(input())
arr = set(map(int,input().split()))
print(solve(arr,n)) | {
"input": [
"2\n6\n4 3 0 1 2 0\n2\n2 5\n"
],
"output": [
"YES\nNO\n"
]
} |
4,782 | 7 | You are playing a new computer game in which you have to fight monsters. In a dungeon you are trying to clear, you met three monsters; the first of them has a health points, the second has b health points, and the third has c.
To kill the monsters, you can use a cannon that, when fired, deals 1 damage to the selected monster. Every 7-th (i. e. shots with numbers 7, 14, 21 etc.) cannon shot is enhanced and deals 1 damage to all monsters, not just one of them. If some monster's current amount of health points is 0, it can't be targeted by a regular shot and does not receive damage from an enhanced shot.
You want to pass the dungeon beautifully, i. e., kill all the monsters with the same enhanced shot (i. e. after some enhanced shot, the health points of each of the monsters should become equal to 0 for the first time). Each shot must hit a monster, i. e. each shot deals damage to at least one monster.
Input
The first line contains a single integer t (1 β€ t β€ 10^4) β the number of test cases.
Each test case consists of a single line that contains three integers a, b and c (1 β€ a, b, c β€ 10^8) β the number of health points each monster has.
Output
For each test case, print YES if you can kill all the monsters with the same enhanced shot. Otherwise, print NO. You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer).
Example
Input
3
3 2 4
1 1 1
10 1 7
Output
YES
NO
NO
Note
In the first test case, you can do as follows: 1-th shot to the first monster, 2-th shot to the second monster, 3-th shot to the third monster, 4-th shot to the first monster, 5-th shot to the third monster, 6-th shot to the third monster, and 7-th enhanced shot will kill all the monsters.
In the second test case, you can't kill monsters with the same enhanced shot, because the total number of health points of monsters is 3, and you will kill them in the first 3 shots. | def solve():
a,b,c = map(int, input().split())
if (a+b+c)%9==0 and min(a,b,c) >=(a+b+c)//9:
print("YES")
else:
print("NO")
#solve()
#
for testis in range(int(input())):
solve() | {
"input": [
"3\n3 2 4\n1 1 1\n10 1 7\n"
],
"output": [
"\nYES\nNO\nNO\n"
]
} |
4,783 | 7 | Β«One dragon. Two dragon. Three dragonΒ», β the princess was counting. She had trouble falling asleep, and she got bored of counting lambs when she was nine.
However, just counting dragons was boring as well, so she entertained herself at best she could. Tonight she imagined that all dragons were here to steal her, and she was fighting them off. Every k-th dragon got punched in the face with a frying pan. Every l-th dragon got his tail shut into the balcony door. Every m-th dragon got his paws trampled with sharp heels. Finally, she threatened every n-th dragon to call her mom, and he withdrew in panic.
How many imaginary dragons suffered moral or physical damage tonight, if the princess counted a total of d dragons?
Input
Input data contains integer numbers k, l, m, n and d, each number in a separate line (1 β€ k, l, m, n β€ 10, 1 β€ d β€ 105).
Output
Output the number of damaged dragons.
Examples
Input
1
2
3
4
12
Output
12
Input
2
3
4
5
24
Output
17
Note
In the first case every first dragon got punched with a frying pan. Some of the dragons suffered from other reasons as well, but the pan alone would be enough.
In the second case dragons 1, 7, 11, 13, 17, 19 and 23 escaped unharmed. | def r(): return int(input())
k, l, m, n, d = r(), r(), r(), r(), r()
print(sum(v % k == 0 or v % l == 0 or v % m == 0 or v % n == 0 for v in range(1, d+1))) | {
"input": [
"2\n3\n4\n5\n24\n",
"1\n2\n3\n4\n12\n"
],
"output": [
"17\n",
"12\n"
]
} |
4,784 | 11 | You have a large rectangular board which is divided into n Γ m cells (the board has n rows and m columns). Each cell is either white or black.
You paint each white cell either red or blue. Obviously, the number of different ways to paint them is 2^w, where w is the number of white cells.
After painting the white cells of the board, you want to place the maximum number of dominoes on it, according to the following rules:
* each domino covers two adjacent cells;
* each cell is covered by at most one domino;
* if a domino is placed horizontally (it covers two adjacent cells in one of the rows), it should cover only red cells;
* if a domino is placed vertically (it covers two adjacent cells in one of the columns), it should cover only blue cells.
Let the value of the board be the maximum number of dominoes you can place. Calculate the sum of values of the board over all 2^w possible ways to paint it. Since it can be huge, print it modulo 998 244 353.
Input
The first line contains two integers n and m (1 β€ n, m β€ 3 β
10^5; nm β€ 3 β
10^5) β the number of rows and columns, respectively.
Then n lines follow, each line contains a string of m characters. The j-th character in the i-th string is * if the j-th cell in the i-th row is black; otherwise, that character is o.
Output
Print one integer β the sum of values of the board over all 2^w possible ways to paint it, taken modulo 998 244 353.
Examples
Input
3 4
**oo
oo*o
**oo
Output
144
Input
3 4
**oo
oo**
**oo
Output
48
Input
2 2
oo
o*
Output
4
Input
1 4
oooo
Output
9 | MOD = 998244353
ninv = pow(9, MOD - 2, MOD)
def f(n):
return ((3 * n + 1) * pow(2, n, MOD) - (1 if n % 2 == 0 else -1)) * ninv
h, w = map(int, input().split())
s = ['*' * (w + 2)] + ['*' + input() + '*' for _ in range(h)] + ['*' * (w + 2)]
c = 0
for i in range(h + 2):
c += s[i].count('o')
ans = 0
for i in range(1, h + 1):
l = []
for j in range(w + 1):
if s[i][j] != s[i][j + 1]:
l.append(j)
for j in range(1, len(l), 2):
ans += f(l[j] - l[j - 1] - 1) * pow(2, c - l[j] + l[j - 1], MOD)
for i in range(1, w + 1):
l = []
for j in range(h + 1):
if s[j][i] != s[j + 1][i]:
l.append(j)
for j in range(1, len(l), 2):
ans += f(l[j] - l[j - 1] - 1) * pow(2, c - l[j] + l[j - 1], MOD)
print(ans % MOD) | {
"input": [
"2 2\noo\no*\n",
"3 4\n**oo\noo*o\n**oo\n",
"3 4\n**oo\noo**\n**oo\n",
"1 4\noooo\n"
],
"output": [
"\n4\n",
"\n144\n",
"\n48\n",
"\n9\n"
]
} |
4,785 | 9 | There are n students numerated from 1 to n. The level of the i-th student is a_i. You need to split the students into stable groups. A group of students is called stable, if in the sorted array of their levels no two neighboring elements differ by more than x.
For example, if x = 4, then the group with levels [1, 10, 8, 4, 4] is stable (because 4 - 1 β€ x, 4 - 4 β€ x, 8 - 4 β€ x, 10 - 8 β€ x), while the group with levels [2, 10, 10, 7] is not stable (7 - 2 = 5 > x).
Apart from the n given students, teachers can invite at most k additional students with arbitrary levels (at teachers' choice). Find the minimum number of stable groups teachers can form from all students (including the newly invited).
For example, if there are two students with levels 1 and 5; x = 2; and k β₯ 1, then you can invite a new student with level 3 and put all the students in one stable group.
Input
The first line contains three integers n, k, x (1 β€ n β€ 200 000, 0 β€ k β€ 10^{18}, 1 β€ x β€ 10^{18}) β the initial number of students, the number of students you can additionally invite, and the maximum allowed level difference.
The second line contains n integers a_1, a_2, ..., a_n (1 β€ a_i β€ 10^{18}) β the students levels.
Output
In the only line print a single integer: the minimum number of stable groups you can split the students into.
Examples
Input
8 2 3
1 1 5 8 12 13 20 22
Output
2
Input
13 0 37
20 20 80 70 70 70 420 5 1 5 1 60 90
Output
3
Note
In the first example you can invite two students with levels 2 and 11. Then you can split the students into two stable groups:
1. [1, 1, 2, 5, 8, 11, 12, 13],
2. [20, 22].
In the second example you are not allowed to invite new students, so you need 3 groups:
1. [1, 1, 5, 5, 20, 20]
2. [60, 70, 70, 70, 80, 90]
3. [420] | from sys import stdin
def read_int():
return int(stdin.readline())
def read_ints():
return map(int, stdin.readline().split(' '))
n, k, x = read_ints()
a = list(read_ints())
a.sort()
delta = []
for i in range(n - 1):
if a[i + 1] - a[i] > x:
delta.append(a[i + 1] - a[i])
delta.sort()
ans = len(delta) + 1
for d in delta:
if k >= (d - 1) // x:
ans -= 1
k -= (d - 1) // x
print(ans)
| {
"input": [
"8 2 3\n1 1 5 8 12 13 20 22\n",
"13 0 37\n20 20 80 70 70 70 420 5 1 5 1 60 90\n"
],
"output": [
"2\n",
"3\n"
]
} |
4,786 | 8 | Let's consider equation:
x2 + s(x)Β·x - n = 0,
where x, n are positive integers, s(x) is the function, equal to the sum of digits of number x in the decimal number system.
You are given an integer n, find the smallest positive integer root of equation x, or else determine that there are no such roots.
Input
A single line contains integer n (1 β€ n β€ 1018) β the equation parameter.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use cin, cout streams or the %I64d specifier.
Output
Print -1, if the equation doesn't have integer positive roots. Otherwise print such smallest integer x (x > 0), that the equation given in the statement holds.
Examples
Input
2
Output
1
Input
110
Output
10
Input
4
Output
-1
Note
In the first test case x = 1 is the minimum root. As s(1) = 1 and 12 + 1Β·1 - 2 = 0.
In the second test case x = 10 is the minimum root. As s(10) = 1 + 0 = 1 and 102 + 1Β·10 - 110 = 0.
In the third test case the equation has no roots. | def s(x):return sum(int(y) for y in str(x))
n = input()
l,n = len(n)*9,int(n)
m,ans=int(n**0.5),-1
for x in range(max(1,m-l),m+1):
if n%x==0 and x*(s(x)+x)==n:
ans=x
print(ans) | {
"input": [
"4\n",
"110\n",
"2\n"
],
"output": [
"-1\n",
"10\n",
"1\n"
]
} |
4,787 | 7 | The Little Elephant loves chess very much.
One day the Little Elephant and his friend decided to play chess. They've got the chess pieces but the board is a problem. They've got an 8 Γ 8 checkered board, each square is painted either black or white. The Little Elephant and his friend know that a proper chessboard doesn't have any side-adjacent cells with the same color and the upper left cell is white. To play chess, they want to make the board they have a proper chessboard. For that the friends can choose any row of the board and cyclically shift the cells of the chosen row, that is, put the last (rightmost) square on the first place in the row and shift the others one position to the right. You can run the described operation multiple times (or not run it at all).
For example, if the first line of the board looks like that "BBBBBBWW" (the white cells of the line are marked with character "W", the black cells are marked with character "B"), then after one cyclic shift it will look like that "WBBBBBBW".
Help the Little Elephant and his friend to find out whether they can use any number of the described operations to turn the board they have into a proper chessboard.
Input
The input consists of exactly eight lines. Each line contains exactly eight characters "W" or "B" without any spaces: the j-th character in the i-th line stands for the color of the j-th cell of the i-th row of the elephants' board. Character "W" stands for the white color, character "B" stands for the black color.
Consider the rows of the board numbered from 1 to 8 from top to bottom, and the columns β from 1 to 8 from left to right. The given board can initially be a proper chessboard.
Output
In a single line print "YES" (without the quotes), if we can make the board a proper chessboard and "NO" (without the quotes) otherwise.
Examples
Input
WBWBWBWB
BWBWBWBW
BWBWBWBW
BWBWBWBW
WBWBWBWB
WBWBWBWB
BWBWBWBW
WBWBWBWB
Output
YES
Input
WBWBWBWB
WBWBWBWB
BBWBWWWB
BWBWBWBW
BWBWBWBW
BWBWBWWW
BWBWBWBW
BWBWBWBW
Output
NO
Note
In the first sample you should shift the following lines one position to the right: the 3-rd, the 6-th, the 7-th and the 8-th.
In the second sample there is no way you can achieve the goal. | #!/usr/bin/python3
def readln(): return tuple(map(int, input().split()))
print('YES' if len([1 for _ in range(8) if input() in ['WB'*4, 'BW'*4]]) == 8 else 'NO')
| {
"input": [
"WBWBWBWB\nBWBWBWBW\nBWBWBWBW\nBWBWBWBW\nWBWBWBWB\nWBWBWBWB\nBWBWBWBW\nWBWBWBWB\n",
"WBWBWBWB\nWBWBWBWB\nBBWBWWWB\nBWBWBWBW\nBWBWBWBW\nBWBWBWWW\nBWBWBWBW\nBWBWBWBW\n"
],
"output": [
"YES",
"NO"
]
} |
4,788 | 7 | The classic programming language of Bitland is Bit++. This language is so peculiar and complicated.
The language is that peculiar as it has exactly one variable, called x. Also, there are two operations:
* Operation ++ increases the value of variable x by 1.
* Operation -- decreases the value of variable x by 1.
A statement in language Bit++ is a sequence, consisting of exactly one operation and one variable x. The statement is written without spaces, that is, it can only contain characters "+", "-", "X". Executing a statement means applying the operation it contains.
A programme in Bit++ is a sequence of statements, each of them needs to be executed. Executing a programme means executing all the statements it contains.
You're given a programme in language Bit++. The initial value of x is 0. Execute the programme and find its final value (the value of the variable when this programme is executed).
Input
The first line contains a single integer n (1 β€ n β€ 150) β the number of statements in the programme.
Next n lines contain a statement each. Each statement contains exactly one operation (++ or --) and exactly one variable x (denoted as letter Β«XΒ»). Thus, there are no empty statements. The operation and the variable can be written in any order.
Output
Print a single integer β the final value of x.
Examples
Input
1
++X
Output
1
Input
2
X++
--X
Output
0 | def main():
x = int(input())
print(sum(
"+" in input() or -1
for _ in range(x)
))
main()
| {
"input": [
"1\n++X\n",
"2\nX++\n--X\n"
],
"output": [
"1\n",
"0\n"
]
} |
4,789 | 7 | β Oh my sweet Beaverette, would you fancy a walk along a wonderful woodland belt with me?
β Of course, my Smart Beaver! Let us enjoy the splendid view together. How about Friday night?
At this point the Smart Beaver got rushing. Everything should be perfect by Friday, so he needed to prepare the belt to the upcoming walk. He needed to cut down several trees.
Let's consider the woodland belt as a sequence of trees. Each tree i is described by the esthetic appeal ai β some trees are very esthetically pleasing, others are 'so-so', and some trees are positively ugly!
The Smart Beaver calculated that he needed the following effects to win the Beaverette's heart:
* The first objective is to please the Beaverette: the sum of esthetic appeal of the remaining trees must be maximum possible;
* the second objective is to surprise the Beaverette: the esthetic appeal of the first and the last trees in the resulting belt must be the same;
* and of course, the walk should be successful: there must be at least two trees in the woodland belt left.
Now help the Smart Beaver! Which trees does he need to cut down to win the Beaverette's heart?
Input
The first line contains a single integer n β the initial number of trees in the woodland belt, 2 β€ n. The second line contains space-separated integers ai β the esthetic appeals of each tree. All esthetic appeals do not exceed 109 in their absolute value.
* to get 30 points, you need to solve the problem with constraints: n β€ 100 (subproblem A1);
* to get 100 points, you need to solve the problem with constraints: n β€ 3Β·105 (subproblems A1+A2).
Output
In the first line print two integers β the total esthetic appeal of the woodland belt after the Smart Beaver's intervention and the number of the cut down trees k.
In the next line print k integers β the numbers of the trees the Beaver needs to cut down. Assume that the trees are numbered from 1 to n from left to right.
If there are multiple solutions, print any of them. It is guaranteed that at least two trees have equal esthetic appeal.
Examples
Input
5
1 2 3 1 2
Output
8 1
1
Input
5
1 -2 3 1 -2
Output
5 2
2 5 | def main():
n, aa = int(input()), list(map(int, input().split()))
partialsum, s, d, ranges = [0] * n, 0, {}, []
for hi, a in enumerate(aa):
if a in d:
base = s + a * 2
for lo in d[a]:
ranges.append((base - partialsum[lo], lo, hi))
d[a].append(hi)
else:
d[a] = [hi]
if a > 0:
s += a
partialsum[hi] = s
s, lo, hi = max(ranges)
res = list(range(1, lo + 1))
for i in range(lo + 1, hi):
if aa[i] < 0:
res.append(i + 1)
res.extend(range(hi + 2, n + 1))
print(s, len(res))
print(" ".join(map(str, res)))
if __name__ == '__main__':
main()
| {
"input": [
"5\n1 2 3 1 2\n",
"5\n1 -2 3 1 -2\n"
],
"output": [
"8 1\n1 ",
"5 2\n2 5 "
]
} |
4,790 | 10 | Jeff has become friends with Furik. Now these two are going to play one quite amusing game.
At the beginning of the game Jeff takes a piece of paper and writes down a permutation consisting of n numbers: p1, p2, ..., pn. Then the guys take turns to make moves, Jeff moves first. During his move, Jeff chooses two adjacent permutation elements and then the boy swaps them. During his move, Furic tosses a coin and if the coin shows "heads" he chooses a random pair of adjacent elements with indexes i and i + 1, for which an inequality pi > pi + 1 holds, and swaps them. But if the coin shows "tails", Furik chooses a random pair of adjacent elements with indexes i and i + 1, for which the inequality pi < pi + 1 holds, and swaps them. If the coin shows "heads" or "tails" and Furik has multiple ways of adjacent pairs to take, then he uniformly takes one of the pairs. If Furik doesn't have any pair to take, he tosses a coin one more time. The game ends when the permutation is sorted in the increasing order.
Jeff wants the game to finish as quickly as possible (that is, he wants both players to make as few moves as possible). Help Jeff find the minimum mathematical expectation of the number of moves in the game if he moves optimally well.
You can consider that the coin shows the heads (or tails) with the probability of 50 percent.
Input
The first line contains integer n (1 β€ n β€ 3000). The next line contains n distinct integers p1, p2, ..., pn (1 β€ pi β€ n) β the permutation p. The numbers are separated by spaces.
Output
In a single line print a single real value β the answer to the problem. The answer will be considered correct if the absolute or relative error doesn't exceed 10 - 6.
Examples
Input
2
1 2
Output
0.000000
Input
5
3 5 2 4 1
Output
13.000000
Note
In the first test the sequence is already sorted, so the answer is 0. | def count(a):
n = len(a)
cnt = 0
for i in range(n):
for j in range(i+1, n):
if a[i] > a[j]:
cnt+=1
return cnt
n = int(input())
p = list(map(int, input().split()))
num = count(p)
print(num*2 - num%2) | {
"input": [
"5\n3 5 2 4 1\n",
"2\n1 2\n"
],
"output": [
"13",
"0"
]
} |
4,791 | 8 | User ainta has a stack of n red and blue balls. He can apply a certain operation which changes the colors of the balls inside the stack.
* While the top ball inside the stack is red, pop the ball from the top of the stack.
* Then replace the blue ball on the top with a red ball.
* And finally push some blue balls to the stack until the stack has total of n balls inside.
If there are no blue balls inside the stack, ainta can't apply this operation. Given the initial state of the stack, ainta wants to know the maximum number of operations he can repeatedly apply.
Input
The first line contains an integer n (1 β€ n β€ 50) β the number of balls inside the stack.
The second line contains a string s (|s| = n) describing the initial state of the stack. The i-th character of the string s denotes the color of the i-th ball (we'll number the balls from top to bottom of the stack). If the character is "R", the color is red. If the character is "B", the color is blue.
Output
Print the maximum number of operations ainta can repeatedly apply.
Please, do not write the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
3
RBR
Output
2
Input
4
RBBR
Output
6
Input
5
RBBRR
Output
6
Note
The first example is depicted below.
The explanation how user ainta applies the first operation. He pops out one red ball, changes the color of the ball in the middle from blue to red, and pushes one blue ball.
<image>
The explanation how user ainta applies the second operation. He will not pop out red balls, he simply changes the color of the ball on the top from blue to red.
<image>
From now on, ainta can't apply any operation because there are no blue balls inside the stack. ainta applied two operations, so the answer is 2.
The second example is depicted below. The blue arrow denotes a single operation.
<image> | n=int(input())
def f(x):
if x=='R': return '1'
else: return '0'
print(2**n-1-int("".join([f(c) for c in reversed(input())]),base=2)) | {
"input": [
"4\nRBBR\n",
"5\nRBBRR\n",
"3\nRBR\n"
],
"output": [
"6\n",
"6\n",
"2\n"
]
} |
4,792 | 7 | Bizon the Champion is called the Champion for a reason.
Bizon the Champion has recently got a present β a new glass cupboard with n shelves and he decided to put all his presents there. All the presents can be divided into two types: medals and cups. Bizon the Champion has a1 first prize cups, a2 second prize cups and a3 third prize cups. Besides, he has b1 first prize medals, b2 second prize medals and b3 third prize medals.
Naturally, the rewards in the cupboard must look good, that's why Bizon the Champion decided to follow the rules:
* any shelf cannot contain both cups and medals at the same time;
* no shelf can contain more than five cups;
* no shelf can have more than ten medals.
Help Bizon the Champion find out if we can put all the rewards so that all the conditions are fulfilled.
Input
The first line contains integers a1, a2 and a3 (0 β€ a1, a2, a3 β€ 100). The second line contains integers b1, b2 and b3 (0 β€ b1, b2, b3 β€ 100). The third line contains integer n (1 β€ n β€ 100).
The numbers in the lines are separated by single spaces.
Output
Print "YES" (without the quotes) if all the rewards can be put on the shelves in the described manner. Otherwise, print "NO" (without the quotes).
Examples
Input
1 1 1
1 1 1
4
Output
YES
Input
1 1 3
2 3 4
2
Output
YES
Input
1 0 0
1 0 0
1
Output
NO | def r(n):
ret = sum(list(map(int,input().split())))
if ret%n==0: return ret//n
else: return (ret//n)+1
print("YES" if (r(5)+r(10)<=int(input())) else "NO") | {
"input": [
"1 0 0\n1 0 0\n1\n",
"1 1 3\n2 3 4\n2\n",
"1 1 1\n1 1 1\n4\n"
],
"output": [
"NO\n",
"YES\n",
"YES\n"
]
} |
4,793 | 8 | One day a well-known sponsor of a well-known contest decided to give every participant of the contest a T-shirt as a present. A natural problem occurred: on the one hand, it is not clear how many T-shirts of what sizes should be ordered, and on the other hand, one doesn't want to order too many T-shirts (and we do not exactly paper the walls with the oversupply). After considerable brain racking and some pre-estimating, the sponsor representatives ordered a certain number of T-shirts of sizes S, M, L, XL and XXL. The T-shirts turned out to bring good luck, that's why on the contest day there built up a line of K participants willing to get one. Every contestant is characterized by his/her desired T-shirt size (so it happens that for all the participants it is also one of the sizes S, M, L, XL and XXL). The participants come up to get a T-shirt one by one and try to choose the most suitable one, choosing it like this. If there is still a T-shirt of the optimal size left, that he/she takes it without further ado. Otherwise the contestant would prefer to choose a T-shirt with the size as close to the optimal one as possible (the distance between neighboring sizes is considered equal to one). If the variant of choice is not unique, the contestant will take a T-shirt of a bigger size (in case he/she grows more). For example, for a person whose optimal size is L the preference list looks like this: L, XL, M, XXL, S. Using the data on how many T-shirts of every size had been ordered by the organizers, on the size of contestants in the line determine who got a T-shirt of what size.
Input
The first line contains five non-negative integers NS, NM, NL, NXL, NXXL not exceeding 1000 which represent the number of T-shirts of the corresponding sizes. The second line contains an integer K (1 β€ K β€ 1000) which represents the number of participants. The next K lines contain the optimal T-shirt sizes for the contestants. The sizes are given in the order in which the participants stand in the line. It is guaranteed that NS + NM + NL + NXL + NXXL β₯ K.
Output
For each contestant, print a line containing the size of the T-shirt he/she got.
Examples
Input
1 0 2 0 1
3
XL
XXL
M
Output
XXL
L
L | l = list(map(int,input().split()))
n = int(input())
r = ["S","M","L","XL","XXL"]
def g(si):
if si < 0 or si >= 5 or not l[si]:
return False
else:
print(r[si])
l[si] = l[si] - 1
return True
for i in range(n):
t = input()
si = r.index(t)
for j in range(5):
if g(si+j) or g(si-j):
break | {
"input": [
"1 0 2 0 1\n3\nXL\nXXL\nM\n"
],
"output": [
"XXL\nL\nL\n"
]
} |
4,794 | 9 | Vanya wants to pass n exams and get the academic scholarship. He will get the scholarship if the average grade mark for all the exams is at least avg. The exam grade cannot exceed r. Vanya has passed the exams and got grade ai for the i-th exam. To increase the grade for the i-th exam by 1 point, Vanya must write bi essays. He can raise the exam grade multiple times.
What is the minimum number of essays that Vanya needs to write to get scholarship?
Input
The first line contains three integers n, r, avg (1 β€ n β€ 105, 1 β€ r β€ 109, 1 β€ avg β€ min(r, 106)) β the number of exams, the maximum grade and the required grade point average, respectively.
Each of the following n lines contains space-separated integers ai and bi (1 β€ ai β€ r, 1 β€ bi β€ 106).
Output
In the first line print the minimum number of essays.
Examples
Input
5 5 4
5 2
4 7
3 1
3 2
2 5
Output
4
Input
2 5 4
5 2
5 2
Output
0
Note
In the first sample Vanya can write 2 essays for the 3rd exam to raise his grade by 2 points and 2 essays for the 4th exam to raise his grade by 1 point.
In the second sample, Vanya doesn't need to write any essays as his general point average already is above average. |
from sys import stdin
stdin.readline
def mp(): return list(map(int, stdin.readline().strip().split()))
def it():return int(stdin.readline().strip())
n,r,avg=mp()
v=[]
k=res=0
for _ in range(n):
a,b=mp()
v+=[[a,b]]
k+=a
v.sort(key=lambda x:x[1])
ans=k
d=(avg*n-ans)
i=0
while d>0:
t=min(r-v[i][0],d)
res+=t*v[i][1]
d-=t
i+=1
print(res) | {
"input": [
"2 5 4\n5 2\n5 2\n",
"5 5 4\n5 2\n4 7\n3 1\n3 2\n2 5\n"
],
"output": [
"0\n",
"4\n"
]
} |
4,795 | 8 | In some country there are exactly n cities and m bidirectional roads connecting the cities. Cities are numbered with integers from 1 to n. If cities a and b are connected by a road, then in an hour you can go along this road either from city a to city b, or from city b to city a. The road network is such that from any city you can get to any other one by moving along the roads.
You want to destroy the largest possible number of roads in the country so that the remaining roads would allow you to get from city s1 to city t1 in at most l1 hours and get from city s2 to city t2 in at most l2 hours.
Determine what maximum number of roads you need to destroy in order to meet the condition of your plan. If it is impossible to reach the desired result, print -1.
Input
The first line contains two integers n, m (1 β€ n β€ 3000, <image>) β the number of cities and roads in the country, respectively.
Next m lines contain the descriptions of the roads as pairs of integers ai, bi (1 β€ ai, bi β€ n, ai β bi). It is guaranteed that the roads that are given in the description can transport you from any city to any other one. It is guaranteed that each pair of cities has at most one road between them.
The last two lines contains three integers each, s1, t1, l1 and s2, t2, l2, respectively (1 β€ si, ti β€ n, 0 β€ li β€ n).
Output
Print a single number β the answer to the problem. If the it is impossible to meet the conditions, print -1.
Examples
Input
5 4
1 2
2 3
3 4
4 5
1 3 2
3 5 2
Output
0
Input
5 4
1 2
2 3
3 4
4 5
1 3 2
2 4 2
Output
1
Input
5 4
1 2
2 3
3 4
4 5
1 3 2
3 5 1
Output
-1 | from itertools import combinations_with_replacement
from collections import deque
#sys.stdin = open("input_py.txt","r")
n, m = map(int, input().split())
G = [ [] for i in range(n)]
for i in range(m):
x, y = map(int, input().split())
x-=1; y-=1
G[x].append(y)
G[y].append(x)
def BFS(s):
dist = [-1 for i in range(n)]
dist[s] = 0
Q = deque()
Q.append(s)
while len(Q) > 0:
v = Q.popleft()
for to in G[v]:
if dist[to] < 0:
dist[to] = dist[v] + 1
Q.append(to)
return dist
Dist = [BFS(i) for i in range(n)]
s1, t1, l1 = map(int, input(). split())
s2, t2, l2 = map(int, input(). split())
s1-=1; t1-=1; s2-=1; t2-=1
if Dist[s1][t1] > l1 or Dist[s2][t2] > l2:
print(-1)
exit(0)
rest = Dist[s1][t1] + Dist[s2][t2]
for i in range(n):
for j in range(n):
if Dist[i][s1] + Dist[i][j] + Dist[j][t1] <= l1 and Dist[i][s2] + Dist[i][j] + Dist[j][t2] <= l2 :
rest = min(rest, Dist[i][j] + Dist[i][s1] + Dist[i][s2] + Dist[j][t1] + Dist[j][t2])
if Dist[i][s1] + Dist[i][j] + Dist[j][t1] <= l1 and Dist[j][s2] + Dist[i][j] + Dist[i][t2] <= l2 :
rest = min(rest, Dist[i][j] + Dist[j][t1] + Dist[j][s2] + Dist[i][s1] + Dist[i][t2])
print(m-rest) | {
"input": [
"5 4\n1 2\n2 3\n3 4\n4 5\n1 3 2\n3 5 1\n",
"5 4\n1 2\n2 3\n3 4\n4 5\n1 3 2\n2 4 2\n",
"5 4\n1 2\n2 3\n3 4\n4 5\n1 3 2\n3 5 2\n"
],
"output": [
"-1\n",
"1",
"0"
]
} |
4,796 | 10 | There is a string s, consisting of capital Latin letters. Let's denote its current length as |s|. During one move it is allowed to apply one of the following operations to it:
* INSERT pos ch β insert a letter ch in the string s in the position pos (1 β€ pos β€ |s| + 1, A β€ ch β€ Z). The letter ch becomes the pos-th symbol of the string s, at that the letters shift aside and the length of the string increases by 1.
* DELETE pos β delete a character number pos (1 β€ pos β€ |s|) from the string s. At that the letters shift together and the length of the string decreases by 1.
* REPLACE pos ch β the letter in the position pos of the line s is replaced by ch (1 β€ pos β€ |s|, A β€ ch β€ Z). At that the length of the string does not change.
Your task is to find in which minimal number of moves one can get a t string from an s string. You should also find the sequence of actions leading to the required results.
Input
The first line contains s, the second line contains t. The lines consist only of capital Latin letters, their lengths are positive numbers from 1 to 1000.
Output
In the first line print the number of moves k in the given sequence of operations. The number should be the minimal possible one. Then print k lines containing one operation each. Print the operations in the format, described above. If there are several solutions, print any of them.
Examples
Input
ABA
ABBBA
Output
2
INSERT 3 B
INSERT 4 B
Input
ACCEPTED
WRONGANSWER
Output
10
REPLACE 1 W
REPLACE 2 R
REPLACE 3 O
REPLACE 4 N
REPLACE 5 G
REPLACE 6 A
INSERT 7 N
INSERT 8 S
INSERT 9 W
REPLACE 11 R | import sys
from array import array # noqa: F401
def input():
return sys.stdin.buffer.readline().decode('utf-8')
s, t = input().rstrip(), input().rstrip()
n, m = len(s), len(t)
dp = [[10**9] * (m + 2) for _ in range(n + 2)]
dp[n][m] = 0
prev = [[(-1, -1)] * (m + 2) for _ in range(n + 2)]
for i in range(n, -1, -1):
for j in range(m, -1, -1):
if i < n and j < m and dp[i][j] > dp[i + 1][j + 1] + (0 if s[i] == t[j] else 1):
dp[i][j] = dp[i + 1][j + 1] + (0 if s[i] == t[j] else 1)
prev[i][j] = (i + 1, j + 1)
if i < n and dp[i][j] > dp[i + 1][j] + 1:
dp[i][j] = dp[i + 1][j] + 1
prev[i][j] = (i + 1, j)
if j < m and dp[i][j] > dp[i][j + 1] + 1:
dp[i][j] = dp[i][j + 1] + 1
prev[i][j] = (i, j + 1)
i, j = 0, 0
ans = []
while i < n or j < m:
ti, tj = prev[i][j]
if i + 1 == ti and j + 1 == tj:
if s[i] != t[j]:
ans.append(f'REPLACE {j+1} {t[j]}')
elif i + 1 == ti:
ans.append(f'DELETE {j+1}')
elif j + 1 == tj:
ans.append(f'INSERT {j+1} {t[j]}')
i, j = ti, tj
sys.stdout.buffer.write((str(len(ans)) + '\n' + '\n'.join(ans)).encode('utf-8'))
| {
"input": [
"ACCEPTED\nWRONGANSWER\n",
"ABA\nABBBA\n"
],
"output": [
"10\nREPLACE 1 W\nREPLACE 2 R\nREPLACE 3 O\nREPLACE 4 N\nREPLACE 5 G\nREPLACE 6 A\nINSERT 7 N\nINSERT 8 S\nINSERT 9 W\nREPLACE 11 R\n",
"2\nINSERT 3 B\nINSERT 4 B\n"
]
} |
4,797 | 8 | The name of one small but proud corporation consists of n lowercase English letters. The Corporation has decided to try rebranding β an active marketing strategy, that includes a set of measures to change either the brand (both for the company and the goods it produces) or its components: the name, the logo, the slogan. They decided to start with the name.
For this purpose the corporation has consecutively hired m designers. Once a company hires the i-th designer, he immediately contributes to the creation of a new corporation name as follows: he takes the newest version of the name and replaces all the letters xi by yi, and all the letters yi by xi. This results in the new version. It is possible that some of these letters do no occur in the string. It may also happen that xi coincides with yi. The version of the name received after the work of the last designer becomes the new name of the corporation.
Manager Arkady has recently got a job in this company, but is already soaked in the spirit of teamwork and is very worried about the success of the rebranding. Naturally, he can't wait to find out what is the new name the Corporation will receive.
Satisfy Arkady's curiosity and tell him the final version of the name.
Input
The first line of the input contains two integers n and m (1 β€ n, m β€ 200 000) β the length of the initial name and the number of designers hired, respectively.
The second line consists of n lowercase English letters and represents the original name of the corporation.
Next m lines contain the descriptions of the designers' actions: the i-th of them contains two space-separated lowercase English letters xi and yi.
Output
Print the new name of the corporation.
Examples
Input
6 1
police
p m
Output
molice
Input
11 6
abacabadaba
a b
b c
a d
e g
f a
b b
Output
cdcbcdcfcdc
Note
In the second sample the name of the corporation consecutively changes as follows:
<image>
<image>
<image>
<image>
<image>
<image> | def main():
n, m = map(int, input().split())
s = input()
l = list("abcdefghijklmnopqrstuvwxyz")
f = l.index
for _ in range(m):
x, y = map(f, input().split())
l[x], l[y] = l[y], l[x]
print(''.join(l[ord(c) - 97] for c in s))
if __name__ == '__main__':
main()
| {
"input": [
"11 6\nabacabadaba\na b\nb c\na d\ne g\nf a\nb b\n",
"6 1\npolice\np m\n"
],
"output": [
"cdcbcdcfcdc\n",
"molice\n"
]
} |
4,798 | 8 | For each string s consisting of characters '0' and '1' one can define four integers a00, a01, a10 and a11, where axy is the number of subsequences of length 2 of the string s equal to the sequence {x, y}.
In these problem you are given four integers a00, a01, a10, a11 and have to find any non-empty string s that matches them, or determine that there is no such string. One can prove that if at least one answer exists, there exists an answer of length no more than 1 000 000.
Input
The only line of the input contains four non-negative integers a00, a01, a10 and a11. Each of them doesn't exceed 109.
Output
If there exists a non-empty string that matches four integers from the input, print it in the only line of the output. Otherwise, print "Impossible". The length of your answer must not exceed 1 000 000.
Examples
Input
1 2 3 4
Output
Impossible
Input
1 2 2 1
Output
0110 | import math
def get_cnt(res):
n = 1 + math.floor(math.sqrt(2 * res))
if n * (n-1) / 2 == res:
return n
else:
return -1
def calc():
cnt = list(map(int, input().split()))
if cnt == [0,0,0,0]:
return '0'
a = get_cnt(cnt[0])
b = get_cnt(cnt[3])
if cnt == [0,0,0,cnt[3]]:
a = 0
if cnt == [cnt[0],0,0,0]:
b = 0
if a == -1 or b == -1 or (a * b) != (cnt[1] + cnt[2]):
return "Impossible"
ans = ['0'] * (a + b)
i = 0
while b > 0:
while cnt[1] >= b:
i = i + 1
cnt[1] -= b
b -= 1
ans[i] = '1'
i += 1
return ''.join(ans)
print(calc())
| {
"input": [
"1 2 2 1\n",
"1 2 3 4\n"
],
"output": [
"0110",
"Impossible\n"
]
} |
4,799 | 9 | Stepan has the newest electronic device with a display. Different digits can be shown on it. Each digit is shown on a seven-section indicator like it is shown on the picture below.
<image>
So, for example, to show the digit 3 on the display, 5 sections must be highlighted; and for the digit 6, 6 sections must be highlighted.
The battery of the newest device allows to highlight at most n sections on the display.
Stepan wants to know the maximum possible integer number which can be shown on the display of his newest device. Your task is to determine this number. Note that this number must not contain leading zeros. Assume that the size of the display is enough to show any integer.
Input
The first line contains the integer n (2 β€ n β€ 100 000) β the maximum number of sections which can be highlighted on the display.
Output
Print the maximum integer which can be shown on the display of Stepan's newest device.
Examples
Input
2
Output
1
Input
3
Output
7 | def max_number(n):
if n % 2 == 1:
return '7' + '1' * ((n - 3) // 2)
return '1' * (n // 2)
print(max_number(int(input())))
| {
"input": [
"3\n",
"2\n"
],
"output": [
"7\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.