source
stringclasses 3
values | instruction
stringlengths 23
3.97k
| input
stringclasses 1
value | output
stringlengths 1
3.75k
|
|---|---|---|---|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
To make Yalalovichik even more satisfied and happy, Jafar decided to invent Yalalovichik strings. A string is called a Yalalovichik string if the set of all of its distinct non-empty substrings is equal to the set of all of its distinct non-empty subsequences.
You are given a string S$S$. You need to find the number of its distinct non-empty substrings which are Yalalovichik strings.
Note: A string A$A$ is called a subsequence of a string B$B$ if A$A$ can be formed by erasing some characters (possibly none) from B$B$. A string A$A$ is called a substring of a string B$B$ if it can be formed by erasing some characters (possibly none) from the beginning of B$B$ and some (possibly none) from the end of B$B$. Two substrings or subsequences are considered different if they are different strings.
-----Input-----
- The first line of the input contains a single integer T$T$ denoting the number of test cases. The description of T$T$ test cases follows.
- The first line of each test case contains a single integer N=|S|$N = |S|$.
- The second line contains the string S$S$.
-----Output-----
For each test case, print a single line containing one integer — the number of distinct Yalalovichik substrings of S$S$.
-----Constraints-----
- 1≤T≤100$1 \le T \le 100$
- 1≤N≤106$1 \le N \le 10^6$
- the sum of N$N$ over all test cases does not exceed 2⋅106$2 \cdot 10^6$
- S$S$ contains only lowercase English letters
-----Example Input-----
1
3
xxx
-----Example Output-----
3
-----Explanation-----
Example case 1: The distinct Yalalovichik substrings are "x", "xx" and "xxx".
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
for _ in range(int(input())):
n,s = int(input()),input().strip()
previ,num,_s,dic = s[0],0,[],{}
for i in s:
if previ == i:
num+=1
continue
_s.append((previ, num))
if previ not in dic or dic[previ]<num:dic[previ] = num
previ,num = i,1
_s.append((previ, num))
if previ not in dic or dic[previ]<num:dic[previ] = num
sum1 = sum(dic.values())
del dic, s
l,dicc = [i for (i, j) in _s],{}
congr = [(l[i], l[i+1]) for i in range(len(l)-1)]
for i in range(len(congr)):
if congr[i] not in dicc:dicc[congr[i]] = set()
dicc[congr[i]].add( (_s[i][1], _s[i+1][1]) )
sum2,ll = 0,[]
for i in dicc.keys():
sortedset,deleted = sorted(list(dicc[i])),[]
for k in range(1, len(sortedset)):
j = sortedset[k]
if j[1]>sortedset[k-1][1]:
ind = k - 1
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Snackdown 2019 is coming! People have started to spread the word and tell other people about the contest.
There are $N$ people numbered $1$ through $N$. Initially, only person $1$ knows about Snackdown. On each day, everyone who already knows about Snackdown tells other people about it. For each valid $i$, person $i$ can tell up to $A_i$ people per day. People spread the information among the people who don't know about Snackdown in the ascending order of their indices; you may assume that no two people try to tell someone about Snackdown at the same moment. Each person is only allowed to start telling other people about Snackdown since the day after he/she gets to know about it (person $1$ can start telling other people already on day $1$). How many days does it take for all people to know about Snackdown?
-----Input-----
- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
- The first line of each test case contains a single integer $N$.
- The second line contains $N$ space-separated integers $A_1, A_2, \dots, A_N$.
-----Output-----
For each test case, print a single line containing one integer — the number of days.
-----Constraints-----
- $1 \le T \le 1,000$
- $2 \le N \le 10^5$
- the sum of $N$ for all test cases does not exceed $10^6$
- $0 \le A_i \le N$ for each valid $i$
- $1 \le A_1$
-----Example Input-----
2
7
2 1 1 5 5 5 5
5
5 1 3 2 1
-----Example Output-----
2
1
-----Explanation-----
Example case 1: On day $1$, person $1$ tells people $2$ and $3$ about Snackdown. On day $2$, the first three people know about Snackdown, so they can tell $2+1+1 = 4$ people about it in a single day. That means the last four people get to know about Snackdown on day $2$, so the total number of days is $2$.
Example case 2: On each day, person $1$ can tell up to $5$ people about Snackdown, so on the first day, he simply tells all people about it and the total number of days is $1$.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
# cook your dish here
test_case = int(input())
while test_case :
n_people = int(input())
array = list(map(int, input().strip().split()))
sums =[0 for i in range(n_people)]
sums[0] = array[0]
for i in range(1, n_people) :
sums[i] = sums[i-1] + array[i]
# print(sums)
k = 1
count = 0
i = 0
while(k < n_people) :
k = k + sums[i]
# print(k)
i = i + sums[i]
count = count + 1
print(count)
test_case -= 1
# 2 1 1 5 5 5 5
# [2, 3, 4, 9, 14, 19, 24]
# 0 1 2 3 4 5 6
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Chef hates unoptimized codes and people who write such codes. One fine day he decided to look through the kitchen's codebase and found a function whose pseudo-code is given here:
input: integer N, list X[1, 2, ..., N], list Y[1, 2, ..., N]
output: integer res
function:
set res = 0;
for i := 1 to N do
for j := 1 to N do
for k := 1 to N do
if (X[i] = X[j]) OR (X[j] = X[k]) OR (X[k] = X[i])
continue
else
set res = max(res, Y[i] + Y[j] + Y[k])
return res
Luckily enough this code gets triggered only if the Head Chef makes a submission. But still there is a possibility that this can crash the judge. So help Chef by writing a new function which does the same thing but is faster.
-----Input-----
- The first line of the input contains an integer T denoting the number of test cases. The description of T test cases follows.
- The first line of each test case contains an integer N denoting the number of elements in the two lists.
- The i-th of the next N lines contains a pair of space-separated integers denoting the values of X[i] and Y[i] respectively.
-----Output-----
For each test case, output an integer corresponding to the return value of the function.
-----Constraints-----
- 1 ≤ T ≤ 10
- 1 ≤ N ≤ 105
- 1 ≤ X[i], Y[i] ≤ 108
-----Example-----
Input
2
3
1 3
3 1
1 2
5
1 3
2 4
1 2
3 2
3 4
Output
0
11
-----Explanation-----
Testcase 2: The maximum is attained when i = 1, j = 2 and k = 5. This leads to res being 3 + 4 + 4 = 11. This value is attained in other iterations as well, but it never exceeds this, and hence this is the answer.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
# cook your dish here
for _ in range(int(input())):
d=dict()
ls=[]
for i in range(int(input())):
ls=list(map(int,input().split()))
if ls[0] in d:
d[ls[0]]=max(ls[1],d[ls[0]])
else:
d[ls[0]]=ls[1]
# print(d)
if len(d)<3:
print(0)
else:
kd=list(d.values())
kd.sort()
# print(kd)
print(kd[-1]+kd[-2]+kd[-3])
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Polycarp is reading a book consisting of $n$ pages numbered from $1$ to $n$. Every time he finishes the page with the number divisible by $m$, he writes down the last digit of this page number. For example, if $n=15$ and $m=5$, pages divisible by $m$ are $5, 10, 15$. Their last digits are $5, 0, 5$ correspondingly, their sum is $10$.
Your task is to calculate the sum of all digits Polycarp has written down.
You have to answer $q$ independent queries.
-----Input-----
The first line of the input contains one integer $q$ ($1 \le q \le 1000$) — the number of queries.
The following $q$ lines contain queries, one per line. Each query is given as two integers $n$ and $m$ ($1 \le n, m \le 10^{16}$) — the number of pages in the book and required divisor, respectively.
-----Output-----
For each query print the answer for it — the sum of digits written down by Polycarp.
-----Example-----
Input
7
1 1
10 1
100 3
1024 14
998244353 1337
123 144
1234312817382646 13
Output
1
45
153
294
3359835
0
427262129093995
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
for _ in range(int(input())):
n, m = list(map(int, input().split()))
A = []
x = 1
while True:
if (m * x) % 10 not in A:
A.append((m * x) % 10)
else:
break
x += 1
s = sum(A)
n //= m
print(s * (n // len(A)) + sum(A[:n % len(A)]))
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
You are given two integer sequences, each of length N: a_1, ..., a_N and b_1, ..., b_N.
There are N^2 ways to choose two integers i and j such that 1 \leq i, j \leq N. For each of these N^2 pairs, we will compute a_i + b_j and write it on a sheet of paper.
That is, we will write N^2 integers in total.
Compute the XOR of these N^2 integers.
Definition of XOR
The XOR of integers c_1, c_2, ..., c_m is defined as follows:
- Let the XOR be X. In the binary representation of X, the digit in the 2^k's place (0 \leq k; k is an integer) is 1 if there are an odd number of integers among c_1, c_2, ...c_m whose binary representation has 1 in the 2^k's place, and 0 if that number is even.
For example, let us compute the XOR of 3 and 5. The binary representation of 3 is 011, and the binary representation of 5 is 101, thus the XOR has the binary representation 110, that is, the XOR is 6.
-----Constraints-----
- All input values are integers.
- 1 \leq N \leq 200,000
- 0 \leq a_i, b_i < 2^{28}
-----Input-----
Input is given from Standard Input in the following format:
N
a_1 a_2 ... a_N
b_1 b_2 ... b_N
-----Output-----
Print the result of the computation.
-----Sample Input-----
2
1 2
3 4
-----Sample Output-----
2
On the sheet, the following four integers will be written: 4(1+3), 5(1+4), 5(2+3) and 6(2+4).
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
#!/usr/bin/env python3
def main():
N = int(input())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
ans = 0
for k in range(30):
C = [x & ((1 << (k+1)) - 1) for x in A]
D = [x & ((1 << (k+1)) - 1) for x in B]
C.sort()
D.sort()
# print(f'k = {k}')
# print(f'C = {C}')
# print(f'D = {D}')
p, q, r = 0, 0, 0
for i in range(N-1, -1, -1):
while p < N:
if C[i] + D[p] >= 1 << k: break
p += 1
while q < N:
if C[i] + D[q] >= 2 << k: break
q += 1
while r < N:
if C[i] + D[r] >= 3 << k: break
r += 1
x = ((q - p) + (N - r)) % 2
# print(p, q, r, x)
ans = ans ^ (x << k)
print(ans)
main()
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
There are N bags, each containing two white balls. The i-th box contains two balls with integers x_i and y_i written on them, respectively.
For each of these bags, you will paint one of the balls red, and paint the other blue.
Afterwards, the 2N balls will be classified according to color.
Then, we will define the following:
- R_{max}: the maximum integer written on a ball painted in red
- R_{min}: the minimum integer written on a ball painted in red
- B_{max}: the maximum integer written on a ball painted in blue
- B_{min}: the minimum integer written on a ball painted in blue
Find the minimum possible value of (R_{max} - R_{min}) \times (B_{max} - B_{min}).
-----Constraints-----
- 1 ≤ N ≤ 200,000
- 1 ≤ x_i, y_i ≤ 10^9
-----Input-----
Input is given from Standard Input in the following format:
N
x_1 y_1
x_2 y_2
:
x_N y_N
-----Output-----
Print the minimum possible value.
-----Sample Input-----
3
1 2
3 4
5 6
-----Sample Output-----
15
The optimal solution is to paint the balls with x_1, x_2, y_3 red, and paint the balls with y_1, y_2, x_3 blue.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
import sys
def input():
return sys.stdin.readline()[:-1]
n = int(input())
d = []
M, m = 0, 10**30
M_of_m, m_of_M = 0, 10**30
for _ in range(n):
x, y = map(int, input().split())
g, l = max(x, y), min(x, y)
d.append([l, g])
M = max(M, g)
m = min(m, l)
M_of_m = max(M_of_m, l)
m_of_M = min(m_of_M, g)
ans1 = (M - m_of_M) * (M_of_m - m)
M_other, m_other = M_of_m, m
m_reversed = 10**30
gap = M_other - m_other
d.sort(key=min)
for i in range(n-1):
M_other = max(M_other, d[i][1])
m_reversed = min(m_reversed, d[i][1])
m_other = min(m_reversed, d[i+1][0])
gap = min(gap, M_other - m_other)
M_other = max(M_other, d[n-1][1])
m_reversed = min(m_reversed, d[i][1])
gap = min(gap, M_other - m_reversed)
ans2 = (M - m) * gap
#print(ans1, ans2)
print(min(ans1, ans2))
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
There is a road with length $l$ meters. The start of the road has coordinate $0$, the end of the road has coordinate $l$.
There are two cars, the first standing at the start of the road and the second standing at the end of the road. They will start driving simultaneously. The first car will drive from the start to the end and the second car will drive from the end to the start.
Initially, they will drive with a speed of $1$ meter per second. There are $n$ flags at different coordinates $a_1, a_2, \ldots, a_n$. Each time when any of two cars drives through a flag, the speed of that car increases by $1$ meter per second.
Find how long will it take for cars to meet (to reach the same coordinate).
-----Input-----
The first line contains one integer $t$ ($1 \leq t \leq 10^4$): the number of test cases.
The first line of each test case contains two integers $n$, $l$ ($1 \leq n \leq 10^5$, $1 \leq l \leq 10^9$): the number of flags and the length of the road.
The second line contains $n$ integers $a_1, a_2, \ldots, a_n$ in the increasing order ($1 \leq a_1 < a_2 < \ldots < a_n < l$).
It is guaranteed that the sum of $n$ among all test cases does not exceed $10^5$.
-----Output-----
For each test case print a single real number: the time required for cars to meet.
Your answer will be considered correct, if its absolute or relative error does not exceed $10^{-6}$. More formally, if your answer is $a$ and jury's answer is $b$, your answer will be considered correct if $\frac{|a-b|}{\max{(1, b)}} \leq 10^{-6}$.
-----Example-----
Input
5
2 10
1 9
1 10
1
5 7
1 2 3 4 6
2 1000000000
413470354 982876160
9 478
1 10 25 33 239 445 453 468 477
Output
3.000000000000000
3.666666666666667
2.047619047619048
329737645.750000000000000
53.700000000000000
-----Note-----
In the first test case cars will meet in the coordinate $5$.
The first car will be in the coordinate $1$ in $1$ second and after that its speed will increase by $1$ and will be equal to $2$ meters per second. After $2$ more seconds it will be in the coordinate $5$. So, it will be in the coordinate $5$ in $3$ seconds.
The second car will be in the coordinate $9$ in $1$ second and after that its speed will increase by $1$ and will be equal to $2$ meters per second. After $2$ more seconds it will be in the coordinate $5$. So, it will be in the coordinate $5$ in $3$ seconds.
In the second test case after $1$ second the first car will be in the coordinate $1$ and will have the speed equal to $2$ meters per second, the second car will be in the coordinate $9$ and will have the speed equal to $1$ meter per second. So, they will meet after $\frac{9-1}{2+1} = \frac{8}{3}$ seconds. So, the answer is equal to $1 + \frac{8}{3} = \frac{11}{3}$.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
import sys
import random
from fractions import Fraction
from math import *
def input():
return sys.stdin.readline().strip()
def iinput():
return int(input())
def finput():
return float(input())
def tinput():
return input().split()
def linput():
return list(input())
def rinput():
return list(map(int, tinput()))
def fiinput():
return list(map(float, tinput()))
def rlinput():
return list(map(int, input().split()))
def trinput():
return tuple(rinput())
def srlinput():
return sorted(list(map(int, input().split())))
def NOYES(fl):
if fl:
print("NO")
else:
print("YES")
def YESNO(fl):
if fl:
print("YES")
else:
print("NO")
def main():
n, l = rinput()
#n = iinput()
#k = iinput()
#m = iinput()
#n = int(sys.stdin.readline().strip())
#n, k = rinput()
#n, m = rinput()
#m, k = rinput()
#n, k, m = rinput()
#n, m, k = rinput()
#k, n, m = rinput()
#k, m, n = rinput()
#m, k, n = rinput()
#m, n, k = rinput()
q = rlinput()
#q = linput()
q = [0] + q + [l]
w, e = [0] * (n + 2), [0] * (n + 2)
for i in range(1, n + 2):
e[n + 1 - i] = e[n + 2 - i] + ((q[-i] - q[-1 - i]) / i)
w[i] = w[i - 1] + ((q[i] - q[i - 1]) / i)
left, right = 0, n + 2
while right > left + 1:
mid = (right + left) // 2
if w[mid] >= e[mid]:
right = mid
else:
left = mid
print((q[right] - q[right - 1] - (max(0, w[right - 1] - e[right]) * (n - right + 2) + max(0, e[right] - w[right - 1]) * right)) / (n + 2) + max(w[right - 1], e[right]))
for i in range(iinput()):
main()
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
You are an evil sorcerer at a round table with $N$ sorcerers (including yourself). You can cast $M$ spells which have distinct powers $p_1, p_2, \ldots, p_M$.
You may perform the following operation any number of times (possibly zero):
- Assign a living sorcerer to each positive integer cyclically to your left starting from yourself ― the closest living sorcerer to your left is assigned to $1$, the next living sorcerer to the left is assigned to $2$ and so on. Note that each living sorcerer (including yourself) is assigned to an infinite number of integers.
- Choose a spell $j$ (possibly a spell you have chosen before) and kill the living sorcerer assigned to $p_j$. You may not cast a spell to kill yourself.
What is the maximum number of sorcerers you can kill using zero or more operations?
-----Input-----
- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
- The first line of each test case contains two space-separated integers $N$ and $M$.
- The second line contains $M$ space-separated integers $p_1, p_2, \ldots, p_M$.
-----Output-----
For each test case, print a single line containing one integer ― the maximum number of sorcerers you can kill.
-----Constraints-----
- $1 \le T \le 1,000$
- $1 \le N \le 10^9$
- $1 \le M \le 3 \cdot 10^5$
- $1 \le p_i \le 10^9$ for each valid $i$
- $p_1, p_2, \ldots, p_N$ are pairwise distinct
- the sum of $M$ over all test cases does not exceed $3 \cdot 10^5$
-----Example Input-----
5
4 1
5
6 2
2 4
1 4
7 16 8 29
1000000000 1
998244353
1 1
20201220
-----Example Output-----
3
4
0
1755647
0
-----Explanation-----
Example case 1: The initial state is shown in the figure from the statement. We can first use spell $1$ and kill the $5$-th sorcerer to our left, i.e. sorcerer $2$. Now there are $3$ living sorcerers and the state is as shown in the following figure:
We can use spell $1$ again and kill the current $5$-th living sorcerer to our left, i.e. sorcerer $4$. Now there are $2$ living sorcerers and the state is:
Finally, we can use spell $1$ again and kill the only other living sorcerer, i.e. sorcerer $3$. Now, none of the other sorcerers are alive. As we cannot cast a spell to kill ourselves, we cannot improve the answer any further.
Example case 2: We can perform $4$ operations using the spell $p_1 = 2$ each time. We can also instead use $p_2 = 4$ in the first two operations and $p_1 = 2$ in the last two operations. Note that there may be multiple valid sequences of operations that lead to the best answer.
Example case 3: We cannot perform any operations using any of the given spells, so we are unable to kill any sorcerers.
Example case 4: We can perform $1,755,647$ operations, each of them using the spell $p_1 = 998,244,353$.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
import functools
def gcd(x,y):
if(y == 0):
return x
return gcd(y, x%y)
for _ in range(int(input())):
n, m= map(int, input().split())
p = list(map(int, input().split()))
ans = functools.reduce(lambda x,y: gcd(x, y), p)
if(ans <= n):
print(n-ans)
else:
f = [1]
for k in range(ans//2, 1, -1):
if ans %k == 0:
if k<=n:
f.append(k)
if ans//k <= n:
f.append(ans//k)
res = n-max(f)
print(res)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
This is a hard version of the problem. In this version, the given array can contain equal elements and the constraints on $n$ are greater than in the easy version of the problem.
You are given an array $a$ of $n$ integers (the given array can contain equal elements). You can perform the following operations on array elements: choose any index $i$ ($1 \le i \le n$) and move the element $a[i]$ to the begin of the array; choose any index $i$ ($1 \le i \le n$) and move the element $a[i]$ to the end of the array.
For example, if $n = 5$, $a = [4, 7, 2, 2, 9]$, then the following sequence of operations can be performed: after performing the operation of the first type to the second element, the array $a$ will become $[7, 4, 2, 2, 9]$; after performing the operation of the second type to the second element, the array $a$ will become $[7, 2, 2, 9, 4]$.
You can perform operations of any type any number of times in any order.
Find the minimum total number of operations of the first and second type that will make the $a$ array sorted in non-decreasing order. In other words, what is the minimum number of operations must be performed so the array satisfies the inequalities $a[1] \le a[2] \le \ldots \le a[n]$.
-----Input-----
The first line contains a single integer $t$ ($1 \le t \le 10^4$) — the number of test cases in the test. Then $t$ test cases follow.
Each test case starts with a line containing an integer $n$ ($1 \le n \le 2 \cdot 10^5$) — the size of the array $a$.
Then follow $n$ integers $a_1, a_2, \ldots, a_n$ ($0 \le a_i \le 10^9$) — an array that needs to be sorted by the given operations. The given array can contain equal elements.
The sum of $n$ for all test cases in one test does not exceed $2 \cdot 10^5$.
-----Output-----
For each test case output one integer — the minimum total number of operations of the first and second type, which will make the array sorted in non-decreasing order.
-----Example-----
Input
9
5
4 7 2 2 9
5
3 5 8 1 7
5
1 2 2 4 5
2
0 1
3
0 1 0
4
0 1 0 0
4
0 1 0 1
4
0 1 0 2
20
16 15 1 10 0 14 0 10 3 9 2 5 4 5 17 9 10 20 0 9
Output
2
2
0
0
1
1
1
1
16
-----Note-----
In the first test case, you first need to move two 2, to the beginning of the array. Therefore, the desired sequence of operations: $[4, 7, 2, 2, 9] \rightarrow [2, 4, 7, 2, 9] \rightarrow [2, 2, 4, 7, 9]$.
In the second test case, you need to move the 1 to the beginning of the array, and the 8 — to the end. Therefore, the desired sequence of operations: $[3, 5, 8, 1, 7] \rightarrow [1, 3, 5, 8, 7] \rightarrow [1, 3, 5, 7, 8]$.
In the third test case, the array is already sorted.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
from sys import stdin
for _ in range(int(input())):
n = int(input())
l = list(map(int,input().split()))
id = list(zip(l,list(range(n))))
id.sort()
val, pos = zip(*id)
blok = []
cur = [pos[0]]
for i in range(1,n):
if val[i] == val[i-1]:
cur.append(pos[i])
else:
cur.sort()
blok.append(cur)
cur = [pos[i]]
cur.sort()
blok.append(cur)
best = 0
m = len(blok)
for j in range(m):
best = max(len(blok[j]), best)
i = 0
while True:
if i >= m-2:
break
cyk = min(blok[i+1])
j = -1
while j+1 < len(blok[i]) and blok[i][j+1] < cyk:
j += 1
su = (j+1)
ii = i+2
while ii < m:
if min(blok[ii]) > max(blok[ii-1]):
su += len(blok[ii-1])
ii += 1
else:
break
if ii == m:
su += len(blok[-1])
best = max(best, su)
else:
xxx = max(blok[ii-1])
su += len(blok[ii-1])
inde = len(blok[ii])-1
while inde >= 0 and blok[ii][inde] >= xxx:
su += 1
inde -= 1
best = max(best,su)
i = max(i+1, ii-1)
for i in range(1,m):
b1 = blok[i];b0 = blok[i-1];l0,l1,i1 = len(b0),len(b1),0
for ind in range(l0):
while True:
if i1 < l1 and b1[i1] <= b0[ind]:i1 += 1
else:break
if l1 == i1:break
best = max(best, (ind+1)+(l1-i1))
print(n-best)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Now that Chef has finished baking and frosting his cupcakes, it's time to package them. Chef has N cupcakes, and needs to decide how many cupcakes to place in each package. Each package must contain the same number of cupcakes. Chef will choose an integer A between 1 and N, inclusive, and place exactly A cupcakes into each package. Chef makes as many packages as possible. Chef then gets to eat the remaining cupcakes. Chef enjoys eating cupcakes very much. Help Chef choose the package size A that will let him eat as many cupcakes as possible.
-----Input-----
Input begins with an integer T, the number of test cases. Each test case consists of a single integer N, the number of cupcakes.
-----Output-----
For each test case, output the package size that will maximize the number of leftover cupcakes. If multiple package sizes will result in the same number of leftover cupcakes, print the largest such size.
-----Constraints-----
- 1 ≤ T ≤ 1000
- 2 ≤ N ≤ 100000000 (108)
-----Sample Input-----
2
2
5
-----Sample Output-----
2
3
-----Explanation-----
In the first test case, there will be no leftover cupcakes regardless of the size Chef chooses, so he chooses the largest possible size. In the second test case, there will be 2 leftover cupcakes.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
for i in range(int(input())):
n=int(input())
print(n//2+1)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
You are given a sequence a_1, a_2, ..., a_{n} consisting of different integers. It is required to split this sequence into the maximum number of subsequences such that after sorting integers in each of them in increasing order, the total sequence also will be sorted in increasing order.
Sorting integers in a subsequence is a process such that the numbers included in a subsequence are ordered in increasing order, and the numbers which are not included in a subsequence don't change their places.
Every element of the sequence must appear in exactly one subsequence.
-----Input-----
The first line of input data contains integer n (1 ≤ n ≤ 10^5) — the length of the sequence.
The second line of input data contains n different integers a_1, a_2, ..., a_{n} ( - 10^9 ≤ a_{i} ≤ 10^9) — the elements of the sequence. It is guaranteed that all elements of the sequence are distinct.
-----Output-----
In the first line print the maximum number of subsequences k, which the original sequence can be split into while fulfilling the requirements.
In the next k lines print the description of subsequences in the following format: the number of elements in subsequence c_{i} (0 < c_{i} ≤ n), then c_{i} integers l_1, l_2, ..., l_{c}_{i} (1 ≤ l_{j} ≤ n) — indices of these elements in the original sequence.
Indices could be printed in any order. Every index from 1 to n must appear in output exactly once.
If there are several possible answers, print any of them.
-----Examples-----
Input
6
3 2 1 6 5 4
Output
4
2 1 3
1 2
2 4 6
1 5
Input
6
83 -75 -49 11 37 62
Output
1
6 1 2 3 4 5 6
-----Note-----
In the first sample output:
After sorting the first subsequence we will get sequence 1 2 3 6 5 4.
Sorting the second subsequence changes nothing.
After sorting the third subsequence we will get sequence 1 2 3 4 5 6.
Sorting the last subsequence changes nothing.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
import sys
#sys.stdin=open("data.txt")
input=sys.stdin.readline
n=int(input())
b=list(map(int,input().split()))
bb=sorted(b)
c={bb[i]:i for i in range(n)}
a=[c[b[i]] for i in range(n)]
vis=[0]*n
out=[]
for i in range(n):
if vis[i]: continue
vis[i]=1
newlist=[i]
while a[newlist[-1]]!=i:
newlist.append(a[newlist[-1]])
vis[newlist[-1]]=1
out.append(newlist)
print(len(out))
for i in out:
print(" ".join([str(x+1) for x in [len(i)-1]+i]))
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
You are given a permutation of 1,2,...,N: p_1,p_2,...,p_N. Determine if the state where p_i=i for every i can be reached by performing the following operation any number of times:
- Choose three elements p_{i-1},p_{i},p_{i+1} (2\leq i\leq N-1) such that p_{i-1}>p_{i}>p_{i+1} and reverse the order of these three.
-----Constraints-----
- 3 \leq N \leq 3 × 10^5
- p_1,p_2,...,p_N is a permutation of 1,2,...,N.
-----Input-----
Input is given from Standard Input in the following format:
N
p_1
:
p_N
-----Output-----
If the state where p_i=i for every i can be reached by performing the operation, print Yes; otherwise, print No.
-----Sample Input-----
5
5
2
1
4
3
-----Sample Output-----
Yes
The state where p_i=i for every i can be reached as follows:
- Reverse the order of p_1,p_2,p_3. The sequence p becomes 1,2,5,4,3.
- Reverse the order of p_3,p_4,p_5. The sequence p becomes 1,2,3,4,5.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
import sys
def solve(ppp):
section_start = -1
moved_left_max = 0
moved_right_max = 0
prev = True
for i, p in enumerate(ppp, start=1):
if i == p:
if prev:
moved_left_max = 0
moved_right_max = 0
section_start = -1
prev = True
else:
if not prev:
if moved_left_max > i - 1:
return False
moved_left_max = 0
moved_right_max = 0
section_start = i
if section_start == -1:
section_start = i
if i > p:
if section_start > p:
return False
if moved_right_max > p:
return False
moved_right_max = p
else:
if moved_left_max > p:
return False
moved_left_max = p
prev = False
return True
n, *ppp = list(map(int, sys.stdin))
print(('Yes' if solve(ppp) else 'No'))
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Walter White and Jesse Pinkman (a drug addict) both love to play with chemicals. One day they were playing with some chemicals to make an energy drink. Unknowingly they made a highly powerful drink. To test the drink on others also they called some of their friends and gave a drop of it to everyone. Now they all were feeling highly energetic and thought of an unique game to play with each other.
After pondering for a while, Jesse came up with an extraordinary idea of competing in a race around a circular globe with N checkpoints each of one unit. Walter and all their other friends agreed with it.They divided themselves in $2$ teams with $N$ teammates in each team.This race has two commencing points $A$ and $B$ strictly facing each other. Walter and his team commences from $A$ point and other team starts from $B$. Both the teams start running at the same time clockwise around the globe. Speed of every player is constant throughout the race. If a player has a speed $X$ then it means that he covers a distance of $X$ units in one second.The race ends when some member of one team overtakes all members of opposite team at any point of time. Now you have to tell if any team will win the race or not.They all are stubborn and can run forever just to win the race. Help them to know if it is possible in anyway that the race will come to an end.
For Clarity, you can visualize the path as a circular paths where $A$ and $B$ are opposite ends of diameter. It can be proven that the actual circumference of circle do not affect the answer.
It is also possible that someone don't run at all.Keep in mind that the fastest one wins the race so does the code.
-----Input:------
- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
- The first line of each test case contains a single integer $N$ number of teammates in both team.
- The second line contains $N$ space-separated integers $A_1, A_2 \ldots A_N$ denoting speed of A's Team
- The third line contains $N$ space-separated integers $B_1, B_2 \ldots B_N$ denoting speed of B's Team
-----Output:------
For each test case, print a single line denoting YES if the race ends at any point of time else NO
-----Constraints-----
- $1 \leq T \leq 10$
- $1 \leq N \leq 10^5$
- $0 \leq A_i \leq 2^{15}$
- $0 \leq B_i \leq 2^{15}$
-----Subtasks-----
Subtask #1 (30 points):
- $1 \le N \le 20$
- $0 \le A_i \le 11$
- $0 \le B_i \le 11$
Subtask #2 (70 points):
- Original constraints
-----Sample input:-----
1
5
1 2 3 4 5
2 7 8 9 9
-----Sample output-----
YES
-----Sample Explanation:------
Team B can overtake all members of Team A.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
# cook your dish here
l1=int(input())
for i in range(l1):
x=int(input())
y=list(map(int,input().split()))
z=list(map(int,input().split()))
if max(z)!=max(y):
print('YES')
else:
print('NO')
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
On each of the following $N$ days (numbered $1$ through $N$), Chef is planning to cook either pizza or broccoli. He wrote down a string $A$ with length $N$, where for each valid $i$, if the character $A_i$ is '1', then he will cook pizza on the $i$-th day, while if $A_i$ is '0', he will cook broccoli on this day.
Chefu, his son, loves pizza but hates broccoli ― just like most kids. He wants to select a substring of $A$ with length $K$ and change each character '0' in this substring to '1'. Afterwards, let's define pizza time as the maximum number of consecutive days where Chef will cook pizza. Find the maximum pizza time Chefu can achieve.
-----Input-----
- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
- The first line of each test case contains two space-separated integers $N$ and $K$.
- The second line contains a string $A$ with length $N$.
-----Output-----
For each test case, print a single line containing one integer ― the maximum pizza time.
-----Constraints-----
- $1 \le T \le 1,000$
- $1 \le K \le N \le 10^5$
- $A$ contains only characters '0' and '1'
- the sum of $N$ over all test cases does not exceed $10^6$
-----Subtasks-----
Subtask #1 (50 points):
- $N \le 10^3$
- the sum of $N$ over all test cases does not exceed $10^4$
Subtask #2 (50 points): original constraints
-----Example Input-----
2
13 2
0101110000101
6 3
100001
-----Example Output-----
5
4
-----Explanation-----
Example case 1: Chefu can choose the substring $A[2, 3]$ = "10", and change the third character of $A$ to '1'. Then, the pizza time is $5$ days: from day $2$ to day $6$.
Example case 2: Chefu can choose the substring $A[2, 4]$ = "000". Then, the pizza time is $4$ days: from day $1$ to day $4$.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
for _ in range(int(input())):
n, k = map(int, input().split())
l = [*map(int, input())]
count = [0] * (n + 1)
for i in range(n - 1, -1, -1):
if l[i] == 1:
count[i] = count[i + 1] + 1
x,y = 0,0
for i in range(n):
if l[i] == 1:
x += 1
else:
try:
y = max(y, x + k + count[i + k])
except:
y = max(y, x + min(k, n - i))
x = 0
y = max(y,x)
print(y)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Devu loves to play with binary strings a lot. One day he borrowed a binary string s of size n from his friend Churu. Before starting to play with it, he wants to make sure that string does not contain more than k consecutive equal characters. For achieving that, only kind of operation he is allowed to perform is to flip any ith character of the string.
As Devu is always in hurry to meet his girlfriend, he wants you to help him in finding out the minimum number of operations he will need. Also he wants you to print one of the possible modified string too.
-----Input-----
- First line of input contains an integer T denoting the number of test cases.
- For each test case, there are two lines.
- First line contains two space separated integers n, k as defined in the problem.
- Next line contains string s of size n.
-----Output-----
- For each test case, print two lines.
- First line should contain an integer corresponding to minimum number of operations Devu needs.
- In second line, print one of the possible modified strings.
-----Constraints-----
Subtask #1: 20 points
- 1 ≤ T ≤ 100, 1 ≤ n ≤ 20, 1 ≤ k ≤ n
Subtask #2: 35 points
- 1 ≤ T ≤ 102, 1 ≤ n ≤ 103, 1 ≤ k ≤ n
Subtask #3: 45 points
- 1 ≤ T ≤ 105, 1 ≤ n ≤ 105, 1 ≤ k ≤ n
- Sum of n over all the test cases is ≤ 106
-----Example-----
Input:
3
2 1
11
2 2
11
4 1
1001
Output:
1
10
0
11
2
1010
-----Explanation-----
Example case 1: As 1 is occurring twice consecutively, we can convert 11 to 10 in a single operation.
Example case 2: You don't need to modify the string as it does not have more than 2 equal consecutive character.
Example case 3: As 0 is occurring twice consecutively, we can convert 1001 to 1010 in a two operations (Flip third and fourth character).
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
T= int(input());
for i in range(T):
n,k = list(map(int,input().split()));
s=list(map(int,input()));
if k==1:
s_0 ={};
s_1={};
c0=0;
c1=0;
for j in range(n):
if(j%2==0):
s_1[j]=1;
s_0[j]=0;
else:
s_1[j]=0;
s_0[j]=1;
for j in range(n):
if(s_0[j]-s[j]!=0):
c0+=1;
if(s_1[j]-s[j]!=0):
c1+=1;
if c0<c1:
print(c0);
p_s="";
for j in range(n):
p_s+=str(s_0[j]);
print(p_s);
else:
print(c1);
p_s="";
for j in range(n):
p_s+=str(s_1[j]);
print(p_s);
else:
count=1;
c=s[0];
flips=0
for j in range(1,n):
if(s[j]==c):
count+=1;
#print count;
if count > k:
if(j+1<n and s[j]==s[j+1]):
if(s[j]==1):
s[j]=0;
else:
s[j]=1;
else:
if(s[j-1]==1):
s[j-1]=0;
else:
s[j-1]=1;
flips+=1;
count=1;
elif(s[j]!=c):
count=1;
c=s[j];
print(flips);
p_s="";
for j in range(n):
p_s+=str(s[j]);
print(p_s);
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
You are given an array consisting of n non-negative integers a_1, a_2, ..., a_{n}.
You are going to destroy integers in the array one by one. Thus, you are given the permutation of integers from 1 to n defining the order elements of the array are destroyed.
After each element is destroyed you have to find out the segment of the array, such that it contains no destroyed elements and the sum of its elements is maximum possible. The sum of elements in the empty segment is considered to be 0.
-----Input-----
The first line of the input contains a single integer n (1 ≤ n ≤ 100 000) — the length of the array.
The second line contains n integers a_1, a_2, ..., a_{n} (0 ≤ a_{i} ≤ 10^9).
The third line contains a permutation of integers from 1 to n — the order used to destroy elements.
-----Output-----
Print n lines. The i-th line should contain a single integer — the maximum possible sum of elements on the segment containing no destroyed elements, after first i operations are performed.
-----Examples-----
Input
4
1 3 2 5
3 4 1 2
Output
5
4
3
0
Input
5
1 2 3 4 5
4 2 3 5 1
Output
6
5
5
1
0
Input
8
5 5 4 4 6 6 5 5
5 2 8 7 1 3 4 6
Output
18
16
11
8
8
6
6
0
-----Note-----
Consider the first sample: Third element is destroyed. Array is now 1 3 * 5. Segment with maximum sum 5 consists of one integer 5. Fourth element is destroyed. Array is now 1 3 * * . Segment with maximum sum 4 consists of two integers 1 3. First element is destroyed. Array is now * 3 * * . Segment with maximum sum 3 consists of one integer 3. Last element is destroyed. At this moment there are no valid nonempty segments left in this array, so the answer is equal to 0.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
__author__ = 'Think'
n=int(input())
aints=[int(i) for i in input().split()]
permutes=[int(i)-1 for i in input().split()]
results=[0]
rebuilt={}
m=0
for numby in range(n-1, 0, -1):
p=permutes[numby]
below=False
above=False
if p-1 in rebuilt:
below=True
if p+1 in rebuilt:
above=True
if above and below:
bsum, bottom=rebuilt[p-1]
asum, top=rebuilt[p+1]
new=bsum+asum+aints[p]
rebuilt[bottom]=(new, top)
rebuilt[top]=(new, bottom)
elif above or below:
if above:
other=p+1
else:
other=p-1
psum, prev=rebuilt[other]
new=psum+aints[p]
rebuilt[prev]=(new, p)
rebuilt[p]=(new, prev)
else:
new=aints[p]
rebuilt[p]=(new, p)
m=max(new, m)
results.append(m)
for numby in range(n-1, -1, -1):
print(results[numby])
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Anna Hazare is a well known social activist in India.
On 5th April, 2011 he started "Lokpal Bill movement".
Chef is very excited about this movement. He is thinking of contributing to it. He gathers his cook-herd and starts thinking about how our community can contribute to this.
All of them are excited about this too, but no one could come up with any idea. Cooks were slightly disappointed with this and went to consult their friends.
One of the geekiest friend gave them the idea of spreading knowledge through Facebook. But we do not want to spam people's wall. So our cook came up with the idea of dividing Facebook users into small friend groups and then identify the most popular friend in each group and post on his / her wall. They started dividing users into groups of friends and identifying the most popular amongst them.
The notoriety of a friend is defined as the averaged distance from all the other friends in his / her group. This measure considers the friend himself, and the trivial distance of '0' that he / she has with himself / herself.
The most popular friend in a group is the friend whose notoriety is least among all the friends in the group.
Distance between X and Y is defined as follows:
Minimum number of profiles that X needs to visit for reaching Y's profile(Including Y's profile). X can open only those profiles which are in the friend list of the current opened profile. For Example:
- Suppose A is friend of B.
- B has two friends C and D.
- E is a friend of D.
Now, the distance between A and B is 1, A and C is 2, C and E is 3.
So, one of our smart cooks took the responsibility of identifying the most popular friend in each group and others will go to persuade them for posting. This cheeky fellow knows that he can release his burden by giving this task as a long contest problem.
Now, he is asking you to write a program to identify the most popular friend among all the friends in each group. Also, our smart cook wants to know the average distance of everyone from the most popular friend.
-----Input-----
Friends in a group are labelled with numbers to hide their Facebook identity. The first line of input contains the number of groups in which users are divided. First line of each group contains the number of friends that belong to that group. ith line of each group contains the space separated friend list of 'i'. You are assured that each friend's profile can be accessed by the profile of every other friend by following some sequence of profile visits.
-----Output-----
Your output contains the most popular friend name label along with the average distance (space separated) from all other friends (including himself / herself) in six digits of precision. There might be multiple most popular friend, in that case output the friend labelled with least number.
-----Note:-----
Each person in a group have atleast one friend and he/she cannot be in his/her own friend list.
Number of friends in a group cannot be more than 100.
There are atmost 100 groups.
-----Example-----
Input:
1
6
3
5
1 4
3 5 6
2 4 6
4 5
Output:
4 1.166667
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
from collections import deque
from sys import stdin
import psyco
psyco.full()
graph = [[]]
WHITE, GRAY, BLACK = 0, 1, 2
def notoriety(x, f_count):
queue = deque([x])
d = [0 for i in range(f_count+1)]
p = [0 for i in range(f_count+1)]
color = [WHITE for i in range(f_count+1)]
while len(queue) > 0:
top = queue.pop()
for node in graph[top]:
if color[node] == WHITE:
queue.appendleft(node)
color[node], p[node], d[node] = GRAY, top, d[top] + 1
color[top] = BLACK
return sum(d)/(f_count*1.0)
def main():
groups = int(stdin.readline())
for g in range(groups):
global graph
graph = [[]]
no_of_friends = int(stdin.readline())
for i in range(no_of_friends):
graph.append(list(map(int,stdin.readline().split())))
min_notoriety, popular = 10000000, -1 # yet another magic number
for f in range(1,no_of_friends+1):
curr_not = notoriety(f, no_of_friends)
if curr_not < min_notoriety:
min_notoriety,popular = curr_not, f
assert popular != -1
print(popular, "%.6f" %min_notoriety)
def __starting_point():
main()
__starting_point()
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
In Snakeland, there are some snakes and mongooses. They are lined up in a row. The information about how exactly they are lined up it is provided to you by a string of length n. If the i-th character of this string is 's', then it means that there is a snake at the i-th position, whereas the character 'm' denotes a mongoose.
You might have heard about the age-old rivalry between hares and tortoises, but in Snakeland, the rivalry between snakes and mongooses is much more famous. The snakes and the mongooses want to hold a final poll in which the ultimate winner of this age-old battle will be decided. If the snakes get more votes than the mongooses, they will be the ultimate winners. Similarly, if the mongooses get more votes than snakes, they will be the ultimate winners. Obviously, each animal is loyal to their species, i.e. each snake will vote for the snakes to be the ultimate champions and each mongoose for the mongooses.
Tomorrow's the election day. Before the elections, the mongooses decided to cheat. They planned that each mongoose will eat at most one of its neighbor snakes. Two animals are said to be neighbors of each other if they are consecutive to each other in the row. After this, the elections will be held. The mongooses planned in such a way that the number of snakes eaten is maximized. Can you find out who will win the final poll? Output "snakes", "mongooses" or "tie" correspondingly.
-----Input-----
First line of the input contains an integer T denoting the number of test cases. The description of T test cases follow.
The only line of each test case contains a string consisting of characters 's' and 'm'.
-----Output-----
For each test case output a single line containing "snakes", "mongooses" or "tie" correspondingly (without quotes).
-----Constraints-----
- 1 ≤ T ≤ 100
- 1 ≤ |s| ≤ 100
-----Example-----
Input
4
sm
ssm
sms
ssmmmssss
Output
mongooses
tie
tie
snakes
-----Explanation-----
Example 1. The mongoose will eat the snake. Only the mongoose will be left. So, on the election day, there is one mongoose and zero snakes. So mongooses will win.
Example 2. The mongoose will eat the snake at position 2 (1-based indexing). One mongoose and one snake will be left. Hence, there will be a tie.
Example 3. The mongoose can eat either the snake to its left or to the right. But, it can eat only one of them. Afterwards, there will be a single snake and mongoose. So, it will result in a tie.
Example 4. The mongooses can eat at max two snakes. For example, s*mmm*sss, where * denotes the snakes that were eaten by mongooses. After this, we have four snakes and three mongooses. So, the snakes win.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
for i in range(int(input())):
a=input()
c=a.count('m')
d=a.count('s')
t=0
while t<len(a)-1:
if (a[t]=='m' and a[t+1]=='s') or (a[t]=='s' and a[t+1]=='m'):
d=d-1
t=t+2
else:
t=t+1
if c>d:
print('mongooses')
elif d>c:
print('snakes')
else:
print('tie')
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
A despotic king decided that his kingdom needed to be rid of corruption and disparity. He called his prime minister and ordered that all corrupt citizens be put to death. Moreover, he wanted this done quickly.
The wily prime minister realised that investigating every citizen to decide who was corrupt and who was not was rather difficult. So he decided on the following plan: He ordered all the citizens to appear in the court one by one and declare their wealth.
The king does not sit in the court all the time (he has other important business to attend to - for instance, meet dignitaries from neighbouring kingdoms, spend time with his family …) Whenever the king walks into the court, the prime minister pulls out the richest man who has appeared before the court so far and is still alive and beheads him for being corrupt. Since the rich are more likely to be corrupt, he hopes to get rid of most of the corrupt and the king is happy as he sees his policy being implemented enthusiastically.
Suppose the wealth of the citizens trooping into the court is
1376518911241376518911241\; 3\; 7\; 6\; 5\; 18\; 9\; 11\; 2\; 4
and the king walked in three times: the first time after the first four persons have seen the minister, the second time after the first five persons have seen the minister and, finally after the first nine persons have seen the minister.
At the king's first visit the richest person to have met the minister has wealth $7$ and he would be beheaded. At the second visit, the wealth of the richest person who has met the minister and is still alive has wealth $6$ and so he would be beheaded. At the third visit the richest person to have met the minister who is still alive has wealth $18$ and so he would be beheaded.
You may assume that the input is such that whenever the king walks in, it is always possible to behead someone.
Your aim is to write a program that will enable the prime minister to identify the richest man to have met the minister and who is still alive quickly. You may assume that no two citizens have the same wealth.
-----Input:-----
The first line of the input consists of two numbers $N$ and $M$, where $N$ is the number of citizens in the kingdom and M is the number of visits to the court by the king.
The next $N+M$ lines describe the order in which the $N$ citizens' appearances are interleaved with the $M$ visits by the king. A citizen's visit is denoted by a positive integer, signifying his wealth. You may assume that no two citizens have the same wealth. A visit by the king is denoted by $-1$.
-----Output:-----
Your output should consist of $M$ lines, where the $i^{th}$ line contains the wealth of the citizen who is beheaded at the $i^{th}$ visit of the king.
-----Constraints:-----
- $1 \leq M \leq 10000$.
- $1 \leq N \leq 100000$.
- You may assume that in $50 \%$ of the inputs $1 \leq M \leq 1000$ and $1 \leq N \leq 8000$.
-----Sample Input-----
10 3
1
3
7
6
-1
5
-1
18
9
11
2
-1
4
-----Sample Output-----
7
6
18
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
n,m=map(int,input().split())
l=[]
leng=0
for i in range(n+m):
w=int(input())
if w==-1:
cm=0
mi=0
for j in range(leng):
if l[j]>cm:
cm=l[j]
mi=j
print(cm)
l[mi]=-1
else:
l.append(w)
leng+=1
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
You were strolling outside the restaurant at the end of the universe. On a metaspiral path you stumble upon a weird device which takes a three-digit number as input and processes it. The Hitchhiker's guide to the galaxy explains that it processes the input in the following manner:
- Multiplies it with 13, followed by 11 and then 7
- Outputs all the distinct three-digit numbers possible from the digits of the new number (each digit can only be used once)
Your friend Zaphod is in a playful mood, and does the following with the device-
- Given a three-digit positive number $K$, he feeds it to the device for processing.
- He then takes the numbers it gives as output, and send each of them through the device and again collect all the numbers sent out.
- Repeats the above step $N$ times.
To test your wit, he challenges you to find the number of distinct 3-digit numbers which the device outputs over the $N$ steps. Can you?
-----Input:-----
- First line will contain $T$, number of testcases. Then the testcases follow.
- Each testcase contains of a single line of input, two integers $K, N$.
-----Output:-----
For each testcase, output a single integer denoting the number of distinct 3-digit numbers which the device outputs over the $N$ steps.
-----Constraints-----
- $1 \leq T \leq 1000$
- $5 \leq N \leq 10^9$
- Each digit of $K$ is non-zero
-----Sample Input:-----
1
123 5
-----Sample Output:-----
27
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
for _ in range(int(input())):
k, n = input().split()
while int(n) >= 5:
print(len(set(k)) ** 3)
break
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
A simple string contains a large repetition of letters within it. This problem is related to string handling and manipulation. An original message is sent from planet Earth to planet Cybertron in form of a string. However, the letter position and string size is not important. The number of time each letter has occurred in the string is important. So the original string which is sent to Cybertron is encrypted in the new string which comprises the letters followed by each time it has occurred in the original string. Eg- original message is- abcdabf. Then the encrypted string is- a2b2c1d1f1
-----Input-----
The input consists of a single line string without any space or numeric or special characters.
-----Output-----
It will consist of in the encrypted string which comprises the letters followed by each time it has occurred in the original string in order.
-----Example-----
Input:
information
Output:
i2n2f1o2r1m1a1t1
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
import sys,math
def main(filename):
inputfile = open(filename,'rU')
data = inputfile.readlines()
T=data.pop(0)
ans=[]
ansstring=str()
explored=[]
for i in T:
if i in explored:
#print explored
for j in range(len(ans)):
if ans[j][0]==i:
ans[j][1] += 1
else:
ans.append([i,1])
explored.append(i)
for i in ans:
ansstring += i[0]+str(i[1])
print(ansstring)
inputfile.close()
def __starting_point():
main(sys.argv[1])
__starting_point()
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Chef has an array of N natural numbers. Cheffina challenges the chef to choose the two numbers from the array and following the condition as the area of the rectangle formed from the two numbers is maximum. Cheffina also asks the chef to choose two numbers different from the previous two to form the rectangle with a minimum area.
-----Input:-----
- First-line will contain $T$, the number of test cases. Then the test cases follow.
- Each test case contains a single line of input, $N$.
- N space-separated natural numbers.
-----Output:-----
For each test case, output in one line answers maximum and minimum area of a rectangle.
-----Constraints-----
- $1 \leq T \leq 10$
- $4 \leq N \leq 10^5$
- $1 \leq arr[i] \leq 10^6$
-----Sample Input:-----
1
5
4 2 1 5 3
-----Sample Output:-----
20 2
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
import sys
import math
import bisect
from sys import stdin,stdout
from math import gcd,floor,sqrt,log
from collections import defaultdict as dd
from bisect import bisect_left as bl,bisect_right as br
sys.setrecursionlimit(100000000)
ii =lambda: int(input())
si =lambda: input()
jn =lambda x,l: x.join(map(str,l))
sl =lambda: list(map(str,input().strip()))
mi =lambda: map(int,input().split())
mif =lambda: map(float,input().split())
lii =lambda: list(map(int,input().split()))
ceil =lambda x: int(x) if(x==int(x)) else int(x)+1
ceildiv=lambda x,d: x//d if(x%d==0) else x//d+1
flush =lambda: stdout.flush()
stdstr =lambda: stdin.readline()
stdint =lambda: int(stdin.readline())
stdpr =lambda x: stdout.write(str(x))
mod=1000000007
#main code
for _ in range(ii()):
n=ii()
arr=lii()
arr.sort()
ma=arr[-1]*arr[-2]
mi=arr[0]*arr[1]
print(ma,mi)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Tracy loves Donuts. She purchased a lots of Donuts for her birthday party. She learnt to calculate the area of the circle a few days back and she is fascinated to know the area of the donuts as well !! Help her finding the area of the Donuts…..
-----Input:-----
- First line will contain, number of testcases. Then the testcases follow.
- Each testcase contains of a single line of input, where in you have to provide the RADIUS of the Donuts.
-----Output:-----
For each testcase, output in a single line answer is the AREA of the Donut.
-----Constraints-----
1 <= Radius <= 20.
-----Sample Input:-----
2
5
12
-----Sample Output:-----
78.5
452.16
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
oo = int(input())
for i in range(oo):
val = int(input())
print((val**2)*3.14)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Little Petya likes points a lot. Recently his mom has presented him n points lying on the line OX. Now Petya is wondering in how many ways he can choose three distinct points so that the distance between the two farthest of them doesn't exceed d.
Note that the order of the points inside the group of three chosen points doesn't matter.
-----Input-----
The first line contains two integers: n and d (1 ≤ n ≤ 10^5; 1 ≤ d ≤ 10^9). The next line contains n integers x_1, x_2, ..., x_{n}, their absolute value doesn't exceed 10^9 — the x-coordinates of the points that Petya has got.
It is guaranteed that the coordinates of the points in the input strictly increase.
-----Output-----
Print a single integer — the number of groups of three points, where the distance between two farthest points doesn't exceed d.
Please do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
-----Examples-----
Input
4 3
1 2 3 4
Output
4
Input
4 2
-3 -2 -1 0
Output
2
Input
5 19
1 10 20 30 50
Output
1
-----Note-----
In the first sample any group of three points meets our conditions.
In the seconds sample only 2 groups of three points meet our conditions: {-3, -2, -1} and {-2, -1, 0}.
In the third sample only one group does: {1, 10, 20}.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
def Search(L,aa,x):
a=aa
b=len(L)
while(b-a>1):
i=(b+a)//2
if(L[i]>x):
b=i
elif(L[i]<x):
a=i
else:
return (i+1)-aa-1
return b-aa-1
import math
n,d=list(map(int,input().split()))
P=list(map(int,input().split()))
ans=0
for i in range(n):
x=Search(P,i,P[i]+d)
if(x>1):
ans+=((x)*(x-1))//2
print(ans)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
$Neha$ is given a number $N$. She always looks for special thing , this time she is looking for $Special$ $Number$ and $Partial$ $Special$ $Number$. A $Special$ $Number$ is a number whose product of its digits is equal to number itself i.e. $N $, and in this number there is no digit $1$. $Partial$ $Special$ is a number having all the condition same as $Special$ except that it can also have digit $1$ in it .Neha have to count the number of $Special$ and $Partial$ $Special$ $Numbers $for a given $N$ . She is not so good in programming , so go and help her.
-----Input:-----
- Integers $N$ is taken as input from input stream.
-----Output:-----
- Print the number of $Special$ and $Partial$ $Special$ $Numbers $for a given $N$.
-----Constraints-----
- $1 \leq N \leq 100$ numbers to be count will be less then 10^6
-----Sample Input:-----
3
-----Sample Output:-----
1 20
-----EXPLANATION:-----
There are only one natural numbers, the product of the digits of which is 3 :- {3}.
There are 20 natural numbers with digit 1 , whose product of the digits is 3 :-{13, 31, 113 ,131 311 ,1113 ,1131 ,1311, 3111 ,11113, 11131, 11311 ,13111, 31111, 111113, 111131, 111311,113111, 131111 ,311111}
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
n=int(input())
a=[]
b=[]
for i in range(1,1000001):
s = str(i)
p=1
flag=0
for e in s:
if e=='1':
flag=1
p=p*int(e)
if p==n:
if flag!=1:
a.append(i)
else:
b.append(i)
print(len(a),len(b))
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Alice and Bob created $N$ and $M$ recipes, respectively ($N, M \ge 1$), and submitted them to Chef for evaluation. Each recipe is represented by a string containing only lowercase English letters. Let's denote Alice's recipes by $A_1, A_2, \ldots, A_N$ and Bob's recipes by $B_1, B_2, \ldots, B_M$.
Accidentally, Chef mixed up those recipes ― now, he has $L = N+M$ recipes in a sequence $S_1, S_2, \ldots, S_L$. Thankfully, the recipes created by Alice and Bob are distinguishable from each other. It is well-known that for each recipe $s$ created by Alice, the following property holds, and for each recipe created by Bob, it does not hold: For each $1 \le l < r \le |s|$, the substring $s_l, s_{l+1}, \ldots, s_r$ contains at least as many vowels as consonants. The letters 'a', 'e', 'i', 'o', 'u' are vowels, while the other letters are consonants.
The score of a candidate who made $K$ recipes is calculated as the product of $\frac{x_c}{fx_c^K}$ for all letters $c$ that occur in at least one of these recipes; here, $x_c$ is the number of recipes which contain the letter $c$ and $fx_c$ is the total number of occurrences of this letter in all $K$ recipes.
Let's denote the scores of Alice and Bob by $sc_A$ and $sc_B$ respectively. Chef wants to know their ratio $sc_A/sc_B$. We know that Chef is a legendary cook, but he is not very good at calculating, so he is asking you to find that number.
-----Input-----
- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
- The first line of each test case contains a single integer $L$.
- $L$ lines follow. For each valid $i$, the $i$-th of these lines contains a single string $S_i$.
-----Output-----
For each test case, if the ratio of scores exceeds $10^7$, print a single line containing the string "Infinity" (without quotes); otherwise, print a single line containing one real number $sc_A/sc_B$.
Your answer will be considered correct if its absolute or relative error does not exceed $10^{-6}$. It is guaranteed that $sc_A/sc_B$ does not lie in the range $10^7 \pm 10$.
-----Constraints-----
- $1 \le T \le 10^5$
- $2 \le L \le 10^5$
- $2 \le |S_i| \le 10^5$ for each valid $i$
- for each valid $i$, $S_i$ contains only lowercase English letters
- the sum of $|S_1| + |S_2| + \ldots + |S_L|$ over all test cases does not exceed $10^7$
-----Subtasks-----
Subtask #1 (25 points):
- $L \le 10$
- $|S_i| \le 10$ for each valid $i$
Subtask #2 (75 points): original constraints
-----Example Input-----
2
4
aba
abc
bab
aac
3
aba
baab
abc
-----Example Output-----
1.1250000
0.0277778
-----Explanation-----
Example case 1: The recipes "aba" and "aac" are created by Alice, while the recipes "abc" and "bab" are created by Bob. The scores are:
- $sc_A = \frac{x_a}{fx_a^N} \cdot \frac{x_b}{fx_b^N} \cdot \frac{x_c}{fx_c^N} = \frac{2}{4^2} \cdot \frac{1}{1^2} \cdot \frac{1}{1^2} = \frac{1}{8}$
- $sc_B = \frac{x_a}{fx_a^M} \cdot \frac{x_b}{fx_b^M} \cdot \frac{x_c}{fx_c^M} = \frac{2}{2^2} \cdot \frac{2}{3^2} \cdot \frac{1}{1^2} = \frac{1}{9}$
- $\frac{sc_A}{sc_B} = \frac{1/8}{1/9} = 1.125$
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
# v = ["a","e","i","o","u"]
# for _ in range(int(input())):
# n = int(input())
# a,b = [],[]
# for i in range(n):
# s = input()
# isa = True
# for j in range(1,len(s) - 1):
# if(s[j] in v):
# if(s[j - 1] not in v and s[j + 1] not in v):
# isa = False
# else:
# if(s[j - 1] not in v or s[j + 1] not in v):
# isa = False
# if(not isa):
# break
# if(s[0] not in v and s[1] not in v):
# isa = False
# if(s[-1] not in v and s[-2] not in v):
# isa = False
# if(isa):
# a.append(s)
# else:
# b.append(s)
# dicta,dictb = {},{}
# for i in a:
# freq = {}
# for j in i:
# if(j in freq):
# freq[j] += 1
# else:
# freq[j] = 1
# for j in freq:
# if(j not in dicta):
# dicta[j] = (1,freq[j])
# else:
# dicta[j] = (dicta[j][0] + 1,dicta[j][1] + freq[j])
# for i in b:
# freq = {}
# for j in i:
# if(j in freq):
# freq[j] += 1
# else:
# freq[j] = 1
# for j in freq:
# if(j not in dictb):
# dictb[j] = (1,freq[j])
# else:
# dictb[j] = (dictb[j][0] + 1,dictb[j][1] + freq[j])
# ans = 1
# for i in dicta:
# ans *= dicta[i][0]
# for i in dictb:
# ans /= dictb[i][0]
# x,y = 1,1
# for i in dictb:
# x *= dictb[i][1]
# for i in dicta:
# y *= dicta[i][1]
# alice,bob = len(a),len(b)
# for i in range(bob):
# while(alice > 0 and ans > 10**7):
# ans /= y
# alice -= 1
# ans *= x
# if(ans > 10**7 and alice == 0):
# break
# while(alice > 0):
# ans /= y
# if(ans < 1 and alice > 100):
# ans = 0
# break
# alice -= 1
# if(ans > 10**7):
# print("Infinity")
# else:
# print(ans)
# #partailly correct [75 pts]
#sys.stdin.readline() and sys.stdout.write() are faster I/O methods than input() and print()
from sys import stdin
z=['a','i','e','o','u']
t=int(stdin.readline())
while(t>0):
t-=1
n=int(stdin.readline())
alice=[]
bob=[]
for j in range(n):
s=str(stdin.readline().strip("\n"))
# print(s)
isalice=True
for i in range(1,len(s)-1):
if(s[i] in z):
if(s[i-1] not in z and s[i+1] not in z):
isalice=False
else:
if(s[i-1] not in z or s[i+1] not in z):
isalice=False
if(not isalice):
break
if(s[0] not in z and s[1] not in z):
isalice=False
if(s[-1] not in z and s[-2] not in z):
isalice=False
if(isalice):
alice.append(s)
else:
bob.append(s)
ali={}
bo={}
for i in alice:
d={}
for j in i:
if(j in d):
d[j]+=1
else:
d[j]=1
for j in d:
if j not in ali:
ali[j]=(1,d[j])
else:
ali[j]=(ali[j][0]+1,ali[j][1]+d[j])
for i in bob:
d={}
for j in i:
if(j in d):
d[j]+=1
else:
d[j]=1
for j in d:
if j not in bo:
bo[j]=(1,d[j])
else:
bo[j]=(bo[j][0]+1,bo[j][1]+d[j])
ans=1
for i in ali:
ans*=ali[i][0]
for i in bo:
ans=ans/bo[i][0]
x=1
y=1
for i in bo:
x=x*bo[i][1]
for i in ali:
y=y*ali[i][1]
# print(x,y)
alice=len(alice)
bob=len(bob)
for i in range(bob):
while(alice>0 and ans>10000000):
ans=ans/y
alice-=1
ans*=x
if(ans>10000000 and alice==0):
break
while(alice>0):
ans=ans/y
if(ans<1 and alice>100):
ans=0
break
alice-=1
if(ans>10000000):
print("Infinity")
else:
print(ans)
#AC
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Bessie has way too many friends because she is everyone's favorite cow! Her new friend Rabbit is trying to hop over so they can play!
More specifically, he wants to get from $(0,0)$ to $(x,0)$ by making multiple hops. He is only willing to hop from one point to another point on the 2D plane if the Euclidean distance between the endpoints of a hop is one of its $n$ favorite numbers: $a_1, a_2, \ldots, a_n$. What is the minimum number of hops Rabbit needs to get from $(0,0)$ to $(x,0)$? Rabbit may land on points with non-integer coordinates. It can be proved that Rabbit can always reach his destination.
Recall that the Euclidean distance between points $(x_i, y_i)$ and $(x_j, y_j)$ is $\sqrt{(x_i-x_j)^2+(y_i-y_j)^2}$.
For example, if Rabbit has favorite numbers $1$ and $3$ he could hop from $(0,0)$ to $(4,0)$ in two hops as shown below. Note that there also exists other valid ways to hop to $(4,0)$ in $2$ hops (e.g. $(0,0)$ $\rightarrow$ $(2,-\sqrt{5})$ $\rightarrow$ $(4,0)$).
$1$ Here is a graphic for the first example. Both hops have distance $3$, one of Rabbit's favorite numbers.
In other words, each time Rabbit chooses some number $a_i$ and hops with distance equal to $a_i$ in any direction he wants. The same number can be used multiple times.
-----Input-----
The input consists of multiple test cases. The first line contains an integer $t$ ($1 \le t \le 1000$) — the number of test cases. Next $2t$ lines contain test cases — two lines per test case.
The first line of each test case contains two integers $n$ and $x$ ($1 \le n \le 10^5$, $1 \le x \le 10^9$) — the number of favorite numbers and the distance Rabbit wants to travel, respectively.
The second line of each test case contains $n$ integers $a_1, a_2, \ldots, a_n$ ($1 \le a_i \le 10^9$) — Rabbit's favorite numbers. It is guaranteed that the favorite numbers are distinct.
It is guaranteed that the sum of $n$ over all the test cases will not exceed $10^5$.
-----Output-----
For each test case, print a single integer — the minimum number of hops needed.
-----Example-----
Input
4
2 4
1 3
3 12
3 4 5
1 5
5
2 10
15 4
Output
2
3
1
2
-----Note-----
The first test case of the sample is shown in the picture above. Rabbit can hop to $(2,\sqrt{5})$, then to $(4,0)$ for a total of two hops. Each hop has a distance of $3$, which is one of his favorite numbers.
In the second test case of the sample, one way for Rabbit to hop $3$ times is: $(0,0)$ $\rightarrow$ $(4,0)$ $\rightarrow$ $(8,0)$ $\rightarrow$ $(12,0)$.
In the third test case of the sample, Rabbit can hop from $(0,0)$ to $(5,0)$.
In the fourth test case of the sample, Rabbit can hop: $(0,0)$ $\rightarrow$ $(5,10\sqrt{2})$ $\rightarrow$ $(10,0)$.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
import sys
#sys.stdin=open("data.txt")
input=sys.stdin.readline
mii=lambda:list(map(int,input().split()))
for _ in range(int(input())):
n,x=mii()
has=0
a=0
for i in mii():
if x==i: has=1
a=max(a,i)
if has:
print(1)
else:
print(max(2,(x-1)//a+1))
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Kajaria has an empty bag and 2 types of tiles -
tiles of type $1$ have the number $X$ written and those of type $2$ have the number $Y$ written on them. He has an infinite supply of both type of tiles.
In one move, Kajaria adds exactly $1$ tile to the bag. He adds a tile of type $1$ with probability $p$ and a tile of type $2$ with probability $(1 - p)$.
If $2$ tiles in the bag have the same number written on them (say $Z$), they are merged into a single tile of twice that number ($2Z$).
Find the expected number of moves to reach the first tile with number $S$ written on it.
Notes on merging:
- Consider that the bag contains tiles $(5, 10, 20, 40)$ and if the new tile added is $5$, then it would merge with the existing $5$ and the bag would now contain $(10, 10, 20, 40)$. The tiles $10$ (already present) and $10$ (newly formed) would then merge in the same move to form $(20, 20, 40)$, and that will form $(40, 40)$, which will form $(80)$.
Kajaria guarantees that:
- $X$ and $Y$ are not divisible by each other.
- A tile with number $S$ can be formed.
-----Input-----
- First line contains a single integer $T$ - the total no. of testcases
- Each testcase is described by $2$ lines:
- $X, Y, S$ - $3$ space-separated natural numbers
- $u, v$ - $2$ space-separated natural numbers describing the probability $p$
The value of $p$ is provided as a fraction in its lowest form $u/v$ ($u$ and $v$ are co-prime)
-----Output-----
- For each testcase, if the expected number of moves can be expressed as a fraction $p/q$ in its lowest form, print $(p * q^{-1})$ modulo $10^9 + 7$, where $q^{-1}$ denotes the modular inverse of $q$ wrt $10^9 + 7$.
-----Constraints-----
- $1 \leq T \leq 10^5$
- $2 \leq X, Y \leq 5 * 10^{17}$
- $1 \leq S \leq 10^{18}$
- $1 \leq u < v \leq 10^{9}$
-----Sample Input-----
1
5 3 96
1 3
-----Sample Output-----
48
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
# cook your dish here
t=int(input())
MOD=1000000007
def mod(n, m=MOD):
n%=m
while n<0: n+=m
return n
def power(n, p):
res=1
while p:
if p%2: res=mod(res*n)
p//=2
n=mod(n*n)
return res
while t:
ma=input().split()
x=int(ma[0])
y=int(ma[1])
s=int(ma[2])
ma=input().split()
u=int(ma[0])
v=int(ma[1])
if s%x==0 and ((s // x) & ((s // x) - 1) == 0):
inv=power(u, MOD-2)
print(mod(mod(mod(s//x)*v)*inv))
else:
inv=power(v-u, MOD-2)
print(mod(mod(mod(s//y)*v)*inv))
t-=1
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
A squarer is a simple and convenient device. You give it some positive integer X and it calculates its square.
Leha is implementing a module of this device which is responsible for squaring the numbers consisting of multiple repetitions of one digit. But it turned out that it's not as simple as he thought.
Please help him now!
-----Input-----
The first line contains one integer T denoting the number of testcases. The descriptions of T test cases follow.
Each of the following T lines contain 2 space-separated integers - N and D, respectively. It means that the number X in the corresponding testcase consists of the digit D repeated N times (in decimal representation).
-----Output-----
As the answer can be very large, we ask you to output its hash which is computed in the following way:
Let's consider the integer answer Y as a 0-indexed array starting from its leftmost digit. The hash function is calculated as:
p0*Y[0] + p1*Y[1] + ... + pM-1*Y[M-1] modulo 109 + 7
where M is the length of the array representation of Y and p equals 23.
-----Constraints-----
- 1 ≤ T ≤ 20
- 1 ≤ D ≤ 9
- Subtask 1 (16 points): 1 ≤ N ≤ 9
- Subtask 2 (25 points): 1 ≤ N ≤ 100
- Subtask 3 (27 points): 1 ≤ N ≤ 2 × 104
- Subtask 4 (32 points): 1 ≤ N ≤ 106
-----Example-----
Input:3
1 4
3 6
3 5
Output:139
40079781
32745632
-----Explanation-----
In the first test case, X = 4 and Y = 16. Its hash equals 1*1 + 23*6 = 139.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
val = 10**9 + 7
def MOD(a,b):
aans = a
ans = 1
while b>0:
ans = (ans*aans)%val
aans = (aans*aans)%val
b/=2
return ans%val
for i in range(eval(input())):
n,d= list(map(int,input().split()))
a=int(str(d)*n)
sqr = str(a*a)
ans =0
count=0
for ii in sqr :
ans= ans+int(ii)*23**count
count+=1
z=int(ii)*ans
print(ans % (10**9+7))
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Our beloved detective, Sherlock is currently trying to catch a serial killer who kills a person each day. Using his powers of deduction, he came to know that the killer has a strategy for selecting his next victim.
The killer starts with two potential victims on his first day, selects one of these two, kills selected victim and replaces him with a new person. He repeats this procedure each day. This way, each day he has two potential victims to choose from. Sherlock knows the initial two potential victims. Also, he knows the murder that happened on a particular day and the new person who replaced this victim.
You need to help him get all the pairs of potential victims at each day so that Sherlock can observe some pattern.
-----Input-----
First line of input contains two names (length of each of them doesn't exceed 10), the two initials potential victims. Next line contains integer n (1 ≤ n ≤ 1000), the number of days.
Next n lines contains two names (length of each of them doesn't exceed 10), first being the person murdered on this day and the second being the one who replaced that person.
The input format is consistent, that is, a person murdered is guaranteed to be from the two potential victims at that time. Also, all the names are guaranteed to be distinct and consists of lowercase English letters.
-----Output-----
Output n + 1 lines, the i-th line should contain the two persons from which the killer selects for the i-th murder. The (n + 1)-th line should contain the two persons from which the next victim is selected. In each line, the two names can be printed in any order.
-----Examples-----
Input
ross rachel
4
ross joey
rachel phoebe
phoebe monica
monica chandler
Output
ross rachel
joey rachel
joey phoebe
joey monica
joey chandler
Input
icm codeforces
1
codeforces technex
Output
icm codeforces
icm technex
-----Note-----
In first example, the killer starts with ross and rachel. After day 1, ross is killed and joey appears. After day 2, rachel is killed and phoebe appears. After day 3, phoebe is killed and monica appears. After day 4, monica is killed and chandler appears.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
import sys
s1, s2 = input().split()
n = int(input())
for _ in range(n):
print(s1, s2)
killed, new = input().split()
if s1 == killed:
s1 = new
else:
s2 = new
print(s1, s2)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Initially, you have the array $a$ consisting of one element $1$ ($a = [1]$).
In one move, you can do one of the following things:
Increase some (single) element of $a$ by $1$ (choose some $i$ from $1$ to the current length of $a$ and increase $a_i$ by one); Append the copy of some (single) element of $a$ to the end of the array (choose some $i$ from $1$ to the current length of $a$ and append $a_i$ to the end of the array).
For example, consider the sequence of five moves:
You take the first element $a_1$, append its copy to the end of the array and get $a = [1, 1]$. You take the first element $a_1$, increase it by $1$ and get $a = [2, 1]$. You take the second element $a_2$, append its copy to the end of the array and get $a = [2, 1, 1]$. You take the first element $a_1$, append its copy to the end of the array and get $a = [2, 1, 1, 2]$. You take the fourth element $a_4$, increase it by $1$ and get $a = [2, 1, 1, 3]$.
Your task is to find the minimum number of moves required to obtain the array with the sum at least $n$.
You have to answer $t$ independent test cases.
-----Input-----
The first line of the input contains one integer $t$ ($1 \le t \le 1000$) — the number of test cases. Then $t$ test cases follow.
The only line of the test case contains one integer $n$ ($1 \le n \le 10^9$) — the lower bound on the sum of the array.
-----Output-----
For each test case, print the answer: the minimum number of moves required to obtain the array with the sum at least $n$.
-----Example-----
Input
5
1
5
42
1337
1000000000
Output
0
3
11
72
63244
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
import math
for _ in range(int(input())):
n=int(input())
if n==1:
print(0)
else:
k=int(n**(0.5))
if k*k<n:
k+=1
# print(n,k)
ans=k-1
if k*(k-1)>=n:
ans+=(k-2)
else:
ans+=(k-1)
print(ans)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
You are given an array $a_1, a_2 \dots a_n$. Calculate the number of tuples $(i, j, k, l)$ such that: $1 \le i < j < k < l \le n$; $a_i = a_k$ and $a_j = a_l$;
-----Input-----
The first line contains a single integer $t$ ($1 \le t \le 100$) — the number of test cases.
The first line of each test case contains a single integer $n$ ($4 \le n \le 3000$) — the size of the array $a$.
The second line of each test case contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \le a_i \le n$) — the array $a$.
It's guaranteed that the sum of $n$ in one test doesn't exceed $3000$.
-----Output-----
For each test case, print the number of described tuples.
-----Example-----
Input
2
5
2 2 2 2 2
6
1 3 3 1 2 3
Output
5
2
-----Note-----
In the first test case, for any four indices $i < j < k < l$ are valid, so the answer is the number of tuples.
In the second test case, there are $2$ valid tuples: $(1, 2, 4, 6)$: $a_1 = a_4$ and $a_2 = a_6$; $(1, 3, 4, 6)$: $a_1 = a_4$ and $a_3 = a_6$.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
class BIT():
def __init__(self,n):
self.BIT=[0]*(n+1)
self.num=n
def query(self,idx):
res_sum = 0
while idx > 0:
res_sum += self.BIT[idx]
idx -= idx&(-idx)
return res_sum
#Ai += x O(logN)
def update(self,idx,x):
while idx <= self.num:
self.BIT[idx] += x
idx += idx&(-idx)
return
import sys,random
input=sys.stdin.readline
for _ in range(int(input())):
n=int(input())
a=list(map(int,input().split()))
pair=[[] for i in range(n+1)]
for i in range(n):
for j in range(i+1,n):
if a[i]==a[j]:
pair[i+1].append(j+1)
bit=BIT(n)
ans=0
for i in range(1,n+1):
minus=bit.query(i)
for r in pair[i]:
ans+=bit.query(r-1)-minus
for r in pair[i]:
bit.update(r,1)
print(ans)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Chef Shifu wanted to celebrate the success of his new restaurant with all his employees. He was willing to host a party and he had decided the location of the party as well. However, Chef Shifu was a shy person and wanted to communicate with the least possible employees to inform them about the party, and that these employees could inform their friends.
Note that an employee could only inform his/her immediate friends about the party, not his/her friends’ friends.
Chef Shifu has a list of all the friendships among his employees. Help him find the minimum number of employees he should inform, so that every employee knows about the celebration party.
-----Input-----
First line contains a single integer T - the total number of testcases.
T testcases follow. For each testcase:
The first line contains 2 space-separated integers N and M - the total number of employees working under Chef Shifu and the number of friendship relations.
M lines follow - each line contains 2 space-separated integers u and v, indicating that employee u is a friend of employee v and vice-versa.
The employees are numbered from 1 to N, and each employee is assigned a distinct integer.
-----Output-----
For each testcase, print the minimum number of employees to be informed on a new line.
-----Constraints-----
Subtask 1: 5 points
1 ≤ T ≤ 5
1 ≤ N ≤ 4
0 ≤ M ≤ N*(N-1)/2
Subtask 2: 35 points
1 ≤ T ≤ 5
1 ≤ N ≤ 15
0 ≤ M ≤ N*(N-1)/2
Subtask 3: 60 points
1 ≤ T ≤ 5
1 ≤ N ≤ 20
0 ≤ M ≤ N*(N-1)/2
-----Example-----
Input
2
3 3
1 2
2 3
1 3
4 3
1 2
2 3
3 4
Output
1
2
Explanation
In testcase 1, since every employee is a friend of every other employee, we just need to select 1 employee.
In testcase 2, selecting employees 2 and 4 would ensure that all 4 employees are represented.
Similarly, selecting employees 1 and 3 would also ensure that all 4 employees are selected.
In both cases, we must select 2 employees in the best case.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
t=int(input())
for _ in range(t):
n,m=map(int,input().split())
mat=[0 for i in range(n)]
#mat=[[0 for i in range(n)] for j in range(n)]
for i in range(m):
u,v=map(int,input().split())
u,v=(u-1),(v-1)
mat[u]|=(1<<v)
mat[v]|=(1<<u)
for i in range(n):
mat[i]|=(1<<i)
goal=(2**n)-1
ans=n
for i in range(1,goal+1):
mvs=0
loc=0
for j in range(n):
if(i&(1<<j)):
loc|=mat[j]
mvs+=1
if(loc==goal):
ans=min(mvs,ans)
print(ans)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Given a set of N natural numbers 1,2,3........N and Q query.For each query you have to calculate the total number of subset in which Ith.
number of set come at Kth postion.Elements of every subset should be in sorted order.
The answer could be very large so you have to print answer modulo 1e9+7.
-----Input:-----
- The first line of input cotains a single integer T denoting the number of test cases.
- For every test case it contains two number N and Q.
- Next Q line contains two number I and K.
-----Output:-----
For each test case print required answer.
-----Constraints and Subtasks:-----
- 1<=T<=5
- 1<=N, K<=4000
- 1<=Q<=1000000
Subtask 3: 5 points
- 1<=T<=5
- 1<=N, K<=16
- 1<=Q<=1000
Subtask 1: 25 points
- T=1
- 1<=N, K<=4000
- 1<=Q<=100000
Subtask 2: 70 points
- Original Constraints.
-----Example:-----
Input:
1
3 3
1 2
2 1
3 2
Output:
0
2
2
-----Explanation:-----
For N=3
total subsets are:
{1}
{2}
{3}
{1,2}
{1,3}
{2,3}
{1,2,3}
Now we can see that for I=1 and K=2 there is no subset in which 1 come at 2nd position so the answer is Zero for that query.
For 2nd query I=2 and K=1 there are two subset i.e {2,3} and {2} in which 2 come at 1st position.
Same for 3rd querry there is two subset i.e{1,3} and {2,3}.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
import math
f = math.factorial
for u in range(eval(input())):
n, q = list(map(int, input().split()))
for j in range(q):
i,k = list(map(int, input().split()))
if k>i:
c=0
print(c)
else:
a=2**(n-i)
b=1
d=int(i-1)
e=1
h=1
g=1
#b=f(i-1)/f(k-1)/f(i-k)
if(k-1>i-k):
for z in range(i-k):
b=b*d
d=d-1
e=e*h
h=h+1
b=b/e
else:
for z in range(k-1):
b=b*d
d=d-1
e=e*g
g=g+1
b=b/e
c=a*b
c=c%1000000007
print(c)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
A permutation p of size n is the sequence p_1, p_2, ..., p_{n}, consisting of n distinct integers, each of them is from 1 to n (1 ≤ p_{i} ≤ n).
A lucky permutation is such permutation p, that any integer i (1 ≤ i ≤ n) meets this condition p_{p}_{i} = n - i + 1.
You have integer n. Find some lucky permutation p of size n.
-----Input-----
The first line contains integer n (1 ≤ n ≤ 10^5) — the required permutation size.
-----Output-----
Print "-1" (without the quotes) if the lucky permutation p of size n doesn't exist.
Otherwise, print n distinct integers p_1, p_2, ..., p_{n} (1 ≤ p_{i} ≤ n) after a space — the required permutation.
If there are multiple answers, you can print any of them.
-----Examples-----
Input
1
Output
1
Input
2
Output
-1
Input
4
Output
2 4 1 3
Input
5
Output
2 5 3 1 4
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
n = int(input())
if n%4 > 1:
print(-1)
else:
a = [n+1>>1]*n
for i in range(n//4):
j = i*2
a[j], a[j+1], a[-2-j], a[-1-j] = j+2, n-j, j+1, n-1-j
print(' '.join(map(str, a)))
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Now that Heidi has made sure her Zombie Contamination level checker works, it's time to strike! This time, the zombie lair is a strictly convex polygon on the lattice. Each vertex of the polygon occupies a point on the lattice. For each cell of the lattice, Heidi knows the level of Zombie Contamination – the number of corners of the cell that are inside or on the border of the lair.
Given this information, Heidi wants to know the exact shape of the lair to rain destruction on the zombies. Help her!
[Image]
-----Input-----
The input contains multiple test cases.
The first line of each test case contains one integer N, the size of the lattice grid (5 ≤ N ≤ 500). The next N lines each contain N characters, describing the level of Zombie Contamination of each cell in the lattice. Every character of every line is a digit between 0 and 4.
Cells are given in the same order as they are shown in the picture above: rows go in the decreasing value of y coordinate, and in one row cells go in the order of increasing x coordinate. This means that the first row corresponds to cells with coordinates (1, N), ..., (N, N) and the last row corresponds to cells with coordinates (1, 1), ..., (N, 1).
The last line of the file contains a zero. This line should not be treated as a test case. The sum of the N values for all tests in one file will not exceed 5000.
-----Output-----
For each test case, give the following output:
The first line of the output should contain one integer V, the number of vertices of the polygon that is the secret lair. The next V lines each should contain two integers, denoting the vertices of the polygon in the clockwise order, starting from the lexicographically smallest vertex.
-----Examples-----
Input
8
00000000
00000110
00012210
01234200
02444200
01223200
00001100
00000000
5
00000
01210
02420
01210
00000
7
0000000
0122100
0134200
0013200
0002200
0001100
0000000
0
Output
4
2 3
2 4
6 6
5 2
4
2 2
2 3
3 3
3 2
3
2 5
4 5
4 2
-----Note-----
It is guaranteed that the solution always exists and is unique. It is guaranteed that in the correct solution the coordinates of the polygon vertices are between 2 and N - 2. A vertex (x_1, y_1) is lexicographically smaller than vertex (x_2, y_2) if x_1 < x_2 or $x_{1} = x_{2} \wedge y_{1} < y_{2}$.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
import math
def lexComp(a, b):
if a[0] != b[0]:
return -1 if a[0] < b[0] else 1
if a[1] != b[1]:
return -1 if a[1] < b[1] else 1
return 0
def turn(a, b, c):
return (b[0] - a[0]) * (c[1] - b[1]) - (b[1] - a[1]) * (c[0] - b[0])
def dist2(a, b):
return (a[0] - b[0]) ** 2 + (a[1] - b[1]) ** 2
def solve(n):
a = [list(map(int, input())) for _ in range(n)]
points = []
for i in range(n):
for j in range(n):
if a[i][j] == 1:
curPoints = []
for dx in range(0, 2):
for dy in range(0, 2):
ok = True
for ddx in range(0, 2):
for ddy in range(0, 2):
x, y = i - 1 + dx + ddx, j - 1 + dy + ddy
if 0 <= x < n and 0 <= y < n and a[x][y] == 0:
ok = False
if ok:
curPoints.append((i + dx, j + dy))
points.append(curPoints[0])
points = list(set(points))
for i in range(1, len(points)):
if lexComp(points[0], points[i]) > 0:
points[0], points[i] = points[i], points[0]
points[1:] = sorted(points[1:], key=lambda p: (math.atan2(p[1] - points[0][1], p[0] - points[0][0]), dist2(p, points[0])))
hull = []
for p in points:
while len(hull) >= 2 and turn(hull[-2], hull[-1], p) <= 0:
hull.pop()
hull.append(p)
hull = [(p[1], n - p[0]) for p in hull]
hull = hull[::-1]
start = 0
for i in range(1, len(hull)):
if lexComp(hull[i], hull[start]) < 0:
start = i
newHull = hull[start:]
newHull.extend(hull[:start])
hull = newHull
print(len(hull))
for p in hull:
print(p[0], p[1])
while True:
n = int(input())
if n == 0:
break
solve(n)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Pankaj likes to eat Ice cream when he is working late into the night. Today has been yet another long day for Pankaj. So, he wants to eat ice cream now. He opens the fridge and sees that he has 2 types of containers holding the ice cream.
The first container is a cone with radius r1 and height h1. There is also a hemisphere on the top of the cone which has the same radius. The other container is a cylindrical with radius r2 and height h2. Pankaj wants to know the amount (volume) of ice cream in both the containers. Since Pankaj is tired after coding all day, you have to help him with this task.
-----Input-----
- The first line of the input contains an integer T denoting the number of test cases. The description of T test cases follows.
- Each test case consists of a single line having the r1, h1, r2 and h2. Each value is given upto 2 decimal places. See example for more information.
-----Output-----
- For each test case, output a single line containing the volumes of the two containers separated by space. The answer is considered correct if it is correct upto 6 decimal places.
-----Constraints-----
- 1 ≤ T ≤ 100
- 0 < r1, h1, r2, h2 ≤ 100
-----Example-----
Input:
2
1.00 1.00 1.00 1.00
3.02 7.23 5.20 6.00
Output:
3.141592654 3.141592654
126.739919445 509.691992118
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
import math
t=eval(input())
while t:
t=t-1
r1,h1,r2,h2=list(map(float,input().split()))
vol1=(math.pi*r1*r1*h1)/3 + (2*math.pi*r1*r1*r1)/3
vol2=math.pi*r2*r2*h2
print("%.8f %.8f" % (vol1,vol2))
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Permutation p is an ordered set of integers p_1, p_2, ..., p_{n}, consisting of n distinct positive integers not larger than n. We'll denote as n the length of permutation p_1, p_2, ..., p_{n}.
Your task is to find such permutation p of length n, that the group of numbers |p_1 - p_2|, |p_2 - p_3|, ..., |p_{n} - 1 - p_{n}| has exactly k distinct elements.
-----Input-----
The single line of the input contains two space-separated positive integers n, k (1 ≤ k < n ≤ 10^5).
-----Output-----
Print n integers forming the permutation. If there are multiple answers, print any of them.
-----Examples-----
Input
3 2
Output
1 3 2
Input
3 1
Output
1 2 3
Input
5 2
Output
1 3 2 4 5
-----Note-----
By |x| we denote the absolute value of number x.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
3
import sys
def __starting_point():
n, k = list(map(int, sys.stdin.readline().split()))
l = []
i = 1
j = k + 1
while i <= j:
l.append(str(i))
i += 1
if j > i:
l.append(str(j))
j -= 1
for i in range(k+2, n+1):
l.append(str(i))
print(' '.join(l))
__starting_point()
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Nobody outside the cooking community knows that Chef is a big fan of Chefgram™ — a social network where chefs and cooks upload their secret kitchen photos.
Recently Chef clicked a beautiful photo, which is represented using 10 pixels in a single row. Respecting Chefgram™'s boolean roots, every pixel is either white or black.
Chefgram™ has N filters. Every filter is a string containing 10 symbols. Every symbol is either '+' or '-'.
- A '+' at the ith position in a filter means that if Chef applies this filter to his photo, the ith pixel will be inverted: it becomes black if it was originally white, and vice versa.
- A '-' at the ith position in a filter string means that if Chef applies this filter to his photo, the ith pixel will remain unchanged.
Chef can apply as many filters as he wants from a list. He can pick any subset of filters and consequently apply them to a photo.
For example:
- Imagine that Chef has a photo "bbwwbbwwbb" (where 'b' stands for black and 'w' stands for white).
- He applies filters "++--++--++", "-+-+-+-+-+".
- Applying the first filter will transform his picture to "wwwwwwwwww".
- Applying the second filter on the transformed picture will give Chef the picture "wbwbwbwbwb".
Even if Chefgram™ has two or more identical filters, they are still considered different!
Chef is extremely interested in knowing how many different subsets of all the Chefgram™ filters can he apply to transform his photo into 10 black pixels?
-----Input-----
- The first line of input contains a single integer T — the number of test cases.
- First line of each test case contains a string S. Each symbol is either 'b' or 'w'. This is Chef's photo.
- Second line of each test case contains a single integer N — the number of Chefgram™ filters.
- Each of the next N lines contains a single string Fi, each symbol of which is either '+' or '-'. This string is the ith Chefgram™ filter.
-----Output-----
- For each test case, output a single line containing a single integer — answer to Chef's question modulo 109+7.
-----Constraints-----
- 1 ≤ T ≤ 5
- |S| = 10
- 1 ≤ N ≤ 10^5
- |Fi| = 10
-----Subtasks-----
- Subtask 1: T ≤ 5; N ≤ 20; Points: 20
- Subtask 2: T ≤ 5; N ≤ 10^3; Points: 30
- Subtask 3: T ≤ 5; N ≤ 10^5; Points: 50
-----Example-----
Input:
3
wwwwwwwwww
3
+-+-+-+-+-
----------
+---------
wbwbwbwbwb
3
+-+-+-+-+-
+-+-------
----+-+-+-
bbbbbbbbbb
2
----------
----------
Output:
0
2
4
-----Explanation-----
Example case 1. There is no filter or combination of filters transforming the picture to whole black.
Example case 2. Chef can either apply the first filter (and invert all whites) or apply the second and third filters in any order.
Example case 3. Picture is already fully black, and we have two different identity filters. Chef can either apply the empty subset of filters, the first filter only, the second filter only, or both.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
import itertools
import numpy as np
b = np.zeros((100001), dtype=np.int)
def power2(a):
b[0] = 1
if b[a] > 0:
return b[a]
else:
for i in range(1,a+1):
b[i] = b[i-1]*2
if b[i] > (10**9+7):
b[i] = b[i]%(10**9+7)
return b[a]
def __starting_point():
t = eval(input())
for i in range(t):
s = input()
n = eval(input())
f_list = []
count = 0
for j in range(n):
f_list.append(input())
inp = ""
bin_list = []
for j in range(len(s)):
if s[j] == 'w':
inp = inp + '0'
else:
inp = inp + '1'
#print inp
a = np.zeros((1024), dtype=np.int)
for j in range(n):
s1 = ""
for k in range(len(f_list[j])):
if f_list[j][k]=='+':
s1 = s1 + '1'
else:
s1 = s1 + '0'
if n < 1024:
bin_list.append(s1)
p = int(s1,2)
if a[p] == 0:
count = count+1
a[p] = a[p]+1
count_2 = 0
#print a
if n < 1024:
dp = np.zeros((n+1,1024) ,dtype=np.int64)
dp[0,0] = 1
for j in range(1,n+1):
for k in range(1024):
#print j-1
#print k^int(bin_list[j-1],2)
dp[j,k] = (dp[j-1][k] + dp[j-1][k^int(bin_list[j-1],2)])%(10**9+7)
#print dp
p = 1023 ^ int(inp,2)
print(dp[n,p]%(10**9+7))
else:
dp = np.zeros((1025,1024) ,dtype=np.int64)
dp[0,0] = 1
for j in range(1,1025):
count_2 = count_2 + 1
if a[j-1] > 0:
l = power2(a[j-1]-1)
for k in range(1024):
#print j-1
#print k^int(bin_list[j-1],2)
if a[j-1] > 0:
dp[j,k] = (((dp[j-1][k] + dp[j-1][k^(j-1)])%(10**9+7)) * l )%(10**9+7)
elif dp[j-1][k] > 0:
dp[j,k] = dp[j-1][k]
if count_2 == count:
break
#print dp
p = 1023 ^ int(inp,2)
print(dp[j,p]%(10**9+7))
__starting_point()
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
You are given two positive integers $A$ and $B$. Find the number of pairs of positive integers $(X, Y)$ such that $1 \le X \le A$, $1 \le Y \le B$ and $X + Y$ is even.
-----Input-----
- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
- The first and only line of each test case contains two space-separated integers $A$ and $B$.
-----Output-----
For each test case, print a single line containing one integer ― the number of valid pairs.
-----Constraints-----
- $1 \le T \le 1,000$
- $1 \le A, B \le 10^9$
-----Subtasks-----
Subtask #1 (10 points): $A, B \le 10$
Subtask #2 (10 points): $A, B \le 1,000$
Subtask #3 (80 points): original constraints
-----Example Input-----
4
1 1
2 3
4 6
8 9
-----Example Output-----
1
3
12
36
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
try:
t=int(input())
while t>0:
[a,b]=[int(x) for x in input().split()]
if a==1 and b==1:
print(1)
continue
if a%2==0:
o1=a//2
e1=a//2
else:
o1=a//2+1
e1=a//2
if b%2==0:
o2=b//2
e2=b//2
else:
o2=b//2+1
e2=b//2
print(e1*e2+o1*o2)
t-=1
except:
pass
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Tavak and Seyyed are good friends. Seyyed is very funny and he told Tavak to solve the following problem instead of longest-path.
You are given l and r. For all integers from l to r, inclusive, we wrote down all of their integer divisors except 1. Find the integer that we wrote down the maximum number of times.
Solve the problem to show that it's not a NP problem.
-----Input-----
The first line contains two integers l and r (2 ≤ l ≤ r ≤ 10^9).
-----Output-----
Print single integer, the integer that appears maximum number of times in the divisors.
If there are multiple answers, print any of them.
-----Examples-----
Input
19 29
Output
2
Input
3 6
Output
3
-----Note-----
Definition of a divisor: https://www.mathsisfun.com/definitions/divisor-of-an-integer-.html
The first example: from 19 to 29 these numbers are divisible by 2: {20, 22, 24, 26, 28}.
The second example: from 3 to 6 these numbers are divisible by 3: {3, 6}.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
l,r = map(int, input().split(" "))
if l == r:
print (l)
else:
print (2)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Nitika was once reading a history book and wanted to analyze it. So she asked her brother to create a list of names of the various famous personalities in the book. Her brother gave Nitika the list. Nitika was furious when she saw the list. The names of the people were not properly formatted. She doesn't like this and would like to properly format it.
A name can have at most three parts: first name, middle name and last name. It will have at least one part. The last name is always present. The rules of formatting a name are very simple:
- Only the first letter of each part of the name should be capital.
- All the parts of the name except the last part should be represented by only two characters. The first character should be the first letter of the part and should be capitalized. The second character should be ".".
Let us look at some examples of formatting according to these rules:
- gandhi -> Gandhi
- mahatma gandhI -> M. Gandhi
- Mohndas KaramChand ganDhi -> M. K. Gandhi
-----Input-----
The first line of the input contains an integer T denoting the number of test cases.
The only line of each test case contains the space separated parts of the name.
-----Output-----
For each case, output the properly formatted name.
-----Constraints-----
- 1 ≤ T ≤ 100
- 2 ≤ Length of each part of the name ≤ 10
- Each part of the name contains the letters from lower and upper case English alphabets (i.e. from 'a' to 'z', or 'A' to 'Z')
-----Subtasks-----
Subtask #1 (40 points)
- There is exactly one part in the name.
Subtask #2 (60 points)
- Original constraints.
-----Example-----
Input:
3
gandhi
mahatma gandhI
Mohndas KaramChand gandhi
Output:
Gandhi
M. Gandhi
M. K. Gandhi
-----Explanation-----
The examples are already explained in the problem statement.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
# cook your dish here
x= int(input())
for i in range(x):
y = list(map(str, input().split()))
j= 0
while j<len(y)-1:
print((y[j][0]).capitalize()+".", end=' ')
j+= 1
print(y[len(y)-1].capitalize())
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
The chef is trying to solve some pattern problems, Chef wants your help to code it. Chef has one number K to form a new pattern. Help the chef to code this pattern problem.
-----Input:-----
-First-line will contain $T$, the number of test cases. Then the test cases follow.
-Each test case contains a single line of input, one integer $K$.
-----Output:-----
For each test case, output as the pattern.
-----Constraints-----
- $1 \leq T \leq 26$
- $1 \leq K \leq 26$
-----Sample Input:-----
2
2
4
-----Sample Output:-----
A
12
A
12
ABC
1234
-----EXPLANATION:-----
No need, else pattern can be decode easily.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
try:
for _ in range(int(input())):
k=int(input())
for i in range(1,k+1):
print(" "*(k-i),end="")
if i%2==1:
for j in range(0,i):
print(chr(65+j),end="")
else:
for j in range(0,i):
print(j+1,end="")
print()
except:
pass
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Polycarp wants to assemble his own keyboard. Layouts with multiple rows are too complicated for him — his keyboard will consist of only one row, where all $26$ lowercase Latin letters will be arranged in some order.
Polycarp uses the same password $s$ on all websites where he is registered (it is bad, but he doesn't care). He wants to assemble a keyboard that will allow to type this password very easily. He doesn't like to move his fingers while typing the password, so, for each pair of adjacent characters in $s$, they should be adjacent on the keyboard. For example, if the password is abacaba, then the layout cabdefghi... is perfect, since characters a and c are adjacent on the keyboard, and a and b are adjacent on the keyboard. It is guaranteed that there are no two adjacent equal characters in $s$, so, for example, the password cannot be password (two characters s are adjacent).
Can you help Polycarp with choosing the perfect layout of the keyboard, if it is possible?
-----Input-----
The first line contains one integer $T$ ($1 \le T \le 1000$) — the number of test cases.
Then $T$ lines follow, each containing one string $s$ ($1 \le |s| \le 200$) representing the test case. $s$ consists of lowercase Latin letters only. There are no two adjacent equal characters in $s$.
-----Output-----
For each test case, do the following:
if it is impossible to assemble a perfect keyboard, print NO (in upper case, it matters in this problem); otherwise, print YES (in upper case), and then a string consisting of $26$ lowercase Latin letters — the perfect layout. Each Latin letter should appear in this string exactly once. If there are multiple answers, print any of them.
-----Example-----
Input
5
ababa
codedoca
abcda
zxzytyz
abcdefghijklmnopqrstuvwxyza
Output
YES
bacdefghijklmnopqrstuvwxyz
YES
edocabfghijklmnpqrstuvwxyz
NO
YES
xzytabcdefghijklmnopqrsuvw
NO
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
T = int(input())
def solve(S):
res = [S[0]]
pos = 0 # think...
for s in S[1:]:
# can we change?
if 0 <= pos-1 < len(res) and res[pos-1] == s:
pos = pos-1
elif 0 <= pos+1 < len(res) and res[pos+1] == s:
pos = pos+1
elif pos == 0 and s not in res:
res.insert(0, s) # pos is still 0
elif pos == len(res)-1 and s not in res:
res.append(s)
pos += 1
else: return None
#print(''.join(res))
for x in range(ord('a'), ord('z')+1):
x = chr(x)
if x not in res:
res.append(x)
return ''.join(res)
for _ in range(T):
res = solve(input())
if res is None:
print('NO')
else:
print('YES')
print(res)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Mikhail walks on a Cartesian plane. He starts at the point $(0, 0)$, and in one move he can go to any of eight adjacent points. For example, if Mikhail is currently at the point $(0, 0)$, he can go to any of the following points in one move: $(1, 0)$; $(1, 1)$; $(0, 1)$; $(-1, 1)$; $(-1, 0)$; $(-1, -1)$; $(0, -1)$; $(1, -1)$.
If Mikhail goes from the point $(x1, y1)$ to the point $(x2, y2)$ in one move, and $x1 \ne x2$ and $y1 \ne y2$, then such a move is called a diagonal move.
Mikhail has $q$ queries. For the $i$-th query Mikhail's target is to go to the point $(n_i, m_i)$ from the point $(0, 0)$ in exactly $k_i$ moves. Among all possible movements he want to choose one with the maximum number of diagonal moves. Your task is to find the maximum number of diagonal moves or find that it is impossible to go from the point $(0, 0)$ to the point $(n_i, m_i)$ in $k_i$ moves.
Note that Mikhail can visit any point any number of times (even the destination point!).
-----Input-----
The first line of the input contains one integer $q$ ($1 \le q \le 10^4$) — the number of queries.
Then $q$ lines follow. The $i$-th of these $q$ lines contains three integers $n_i$, $m_i$ and $k_i$ ($1 \le n_i, m_i, k_i \le 10^{18}$) — $x$-coordinate of the destination point of the query, $y$-coordinate of the destination point of the query and the number of moves in the query, correspondingly.
-----Output-----
Print $q$ integers. The $i$-th integer should be equal to -1 if Mikhail cannot go from the point $(0, 0)$ to the point $(n_i, m_i)$ in exactly $k_i$ moves described above. Otherwise the $i$-th integer should be equal to the the maximum number of diagonal moves among all possible movements.
-----Example-----
Input
3
2 2 3
4 3 7
10 1 9
Output
1
6
-1
-----Note-----
One of the possible answers to the first test case: $(0, 0) \to (1, 0) \to (1, 1) \to (2, 2)$.
One of the possible answers to the second test case: $(0, 0) \to (0, 1) \to (1, 2) \to (0, 3) \to (1, 4) \to (2, 3) \to (3, 2) \to (4, 3)$.
In the third test case Mikhail cannot reach the point $(10, 1)$ in 9 moves.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
q=int(input())
for e in range(q):
x,y,k=list(map(int,input().split()))
x,y=abs(x),abs(y)
x,y=max(x,y),min(x,y)
if(x%2!=k%2):
k-=1
y-=1
if(x>k):
print(-1)
continue
if((x-y)%2):
k-=1
x-=1
print(k)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Chef recently opened a big e-commerce website where her recipes can be bought online. It's Chef's birthday month and so she has decided to organize a big sale in which grand discounts will be provided.
In this sale, suppose a recipe should have a discount of x percent and its original price (before the sale) is p. Statistics says that when people see a discount offered over a product, they are more likely to buy it. Therefore, Chef decides to first increase the price of this recipe by x% (from p) and then offer a discount of x% to people.
Chef has a total of N types of recipes. For each i (1 ≤ i ≤ N), the number of recipes of this type available for sale is quantityi, the unit price (of one recipe of this type, before the x% increase) is pricei and the discount offered on each recipe of this type (the value of x) is discounti.
Please help Chef find the total loss incurred due to this sale, if all the recipes are sold out.
-----Input-----
- The first line of the input contains a single integer T denoting the number of test cases. The description of T test cases follows.
- The first line of each test case contains a single integer N denoting the number of recipe types.
- N lines follow. The i-th of these lines contains three space-separated integers pricei, quantityi and discounti describing the i-th recipe type.
-----Output-----
For each test case, print a single line containing one real number — the total amount of money lost. Your answer will be considered correct if it has an absolute error less than 10-2.
-----Constraints-----
- 1 ≤ T ≤ 10
- 1 ≤ N ≤ 105
- 1 ≤ pricei, quantityi ≤ 100 for each valid i
- 0 ≤ discounti ≤ 100 for each valid i
-----Subtasks-----
Subtask #1 (30 points): 1 ≤ N ≤ 100
Subtask #2 (70 points): original constraints
-----Example-----
Input:
2
2
100 5 10
100 1 50
3
10 10 0
79 79 79
100 1 100
Output:
30.000000000
3995.0081000
-----Explanation-----
Example case 1: There are two recipes.
There are 5 recipes of the first type, each of them has a price of 100 and there is a 10% discount provided on it. Therefore, Chef first increases the price of each recipe by 10%, from 100 to 110. After that, she decreases the price by 10%, which makes the final price 99. The amount of money lost for each unit is 1, thus losing 5 for recipes of the first type.
There is only one recipe of the second type, with price 100 and a 50% discount. Therefore, Chef increases the price of the recipe by 50% from 100 to 150 and after that, she decreases its price by 50% to make its final price 75. She loses 25 for this recipe.
Overall, the amount of money Chef loses is 30.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
for i in range(int(input())):
n=int(input())
s=0
for i in range(n):
a,b,c=map(int,input().split())
d=(c/100)*a
e=a+d
f=e-((c/100)*e)
g=a-f
h=b*g
s=s+h
print(s)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
You are given a weighted undirected graph consisting of n$n$ nodes and m$m$ edges. The nodes are numbered from 1$1$ to n$n$. The graph does not contain any multiple edges or self loops.
A walk W$W$ on the graph is a sequence of vertices (with repetitions of vertices and edges allowed) such that every adjacent pair of vertices in the sequence is an edge of the graph. We define the cost of a walk W$W$, Cost(W)$Cost(W)$, as the maximum over the weights of the edges along the walk.
You will be given q$q$ queries. In each query, you will be given an integer X$X$.
You have to count the number of different walks W$W$ of length 4$4$ such that Cost(W)$Cost(W)$ = X$X$.
Two walks are considered different if they do not represent the same edge sequence.
-----Input:-----
- First line contains 2 integers : the number of nodes n$n$ and number of edges m$m$.
- Next m$m$ lines each describe u$u$, v$v$ and w$w$, describing an edge between u$u$ and v$v$ with weight w$w$.
- Next line contains q$q$, the number of queries.
- Next q$q$ lines each describe an integer X$X$ - the cost of the walk in the query.
-----Output:-----
For each query, output in a single line the number of different possible walks.
-----Constraints-----
- 1≤n≤100$1 \leq n \leq 100$
- 1≤m≤n(n−1)2$1 \leq m \leq \frac{n (n-1)}{2}$
- 1≤u,v≤n$1 \leq u, v \leq n$
- 1≤w≤100$1 \leq w \leq 100$
- 1≤q≤100$1 \leq q \leq 100$
- 1≤X≤100$1 \leq X \leq 100$
-----Sample Input:-----
3 3
1 2 1
2 3 2
3 1 3
3
1
2
3
-----Sample Output:-----
2
10
36
-----EXPLANATION:-----
For X=2$X = 2$, all possible 10$10$ walks are listed below :
- 1 -> 2 -> 1 -> 2 -> 3
- 1 -> 2 -> 3 -> 2 -> 1
- 1 -> 2 -> 3 -> 2 -> 3
- 2 -> 1 -> 2 -> 3 -> 2
- 2 -> 3 -> 2 -> 1 -> 2
- 2 -> 3 -> 2 -> 3 -> 2
- 3 -> 2 -> 1 -> 2 -> 1
- 3 -> 2 -> 1 -> 2 -> 3
- 3 -> 2 -> 3 -> 2 -> 1
- 3 -> 2 -> 3 -> 2 -> 3
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
# cook your dish here
from collections import defaultdict
class sol():
def __init__(self,n,edges):
self.n = n
self.edges = edges
self.graph = self.create_graph()
self.precompute()
def create_graph(self):
graph = defaultdict(list)
for e in self.edges:
u = e[0]
v = e[1]
w = e[2]
graph[u].append([v,w])
graph[v].append([u,w])
return graph
def precompute(self):
self.maxiedges = [0]*6
self.B = [[0 for i in range(101)] for i in range(101)]
def func(u,v,l):
if l==2:
self.B[u][self.maxiedges[l]] += 1
else:
for j in self.graph[v]:
self.maxiedges[l+1] = max(self.maxiedges[l],j[1])
func(u,j[0],l+1)
for i in range(1,self.n+1):
func(i,i,0)
def paths(self,X):
freq = 0
for u in range(1,self.n+1):
for x in range(X+1):
freq += 2*self.B[u][X]*self.B[u][x]
freq -= self.B[u][X]*self.B[u][X]
return freq
n, m = map(int, input().split())
edges = []
while m:
uvw = list(map(int, input().split()))
edges.append(uvw)
m -= 1
q = int(input())
Graph = sol(n,edges)
while q:
query = int(input())
print(Graph.paths(query))
q -= 1
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Write a program to obtain a number $N$ and increment its value by 1 if the number is divisible by 4 $otherwise$ decrement its value by 1.
-----Input:-----
- First line will contain a number $N$.
-----Output:-----
Output a single line, the new value of the number.
-----Constraints-----
- $0 \leq N \leq 1000$
-----Sample Input:-----
5
-----Sample Output:-----
4
-----EXPLANATION:-----
Since 5 is not divisible by 4 hence, its value is decreased by 1.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
# cook your dish here
n = int(input())
if(n%4==0):
print(n+1)
else:
print(n-1)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Chef is playing with an expression which consists of integer operands and the following binary
Bitwise operators - AND, OR and XOR. He is trying to figure out that what could be the Maximum possible answer of the expression, given that he can perform the operation in any order i.e not necessarily follow the rule of Precedence of operators while evaluating the expression.
After some time of consistent work Chef starts feeling exhausted and wants you to automate this process for him. Can you help him out?
The expression has Bitwise operators in symbol format:
- & stands for AND
- | stands for OR
- ^ stands for XOR
NOTE : It is guaranteed that the expression will always be valid, also each OPERATOR will always be preceded and succeeded by an OPERAND.
-----Input:-----
- The first line of input contains a single integer $T$ denoting the number of test cases.
- The only line of input for each test case is a $string$ which is the Chef's expression to evaluate.
-----Output:-----
For each test case print a single integer i.e the maximum possible value of Chef's expression.
-----Constraints-----
- $1 \leq T \leq 100$.
- The number of OPERATORS in the expression will be atleast 1 and atmost 10.
- Each OPERAND may range from 0 to $10^9$.
-----Subtasks-----
- 10 points : The number of OPERATORS in the expression will be atmost 5.
- 20 points : The number of OPERATORS in the expression will be atmost 8.
- 70 points : Original constraints.
-----Sample Input:-----
2
3^40|10^2
92^95|56&2&3
-----Sample Output:-----
43
95
-----EXPLANATION:-----CASE 2 :
- If we first compute (56 & 2), the expression becomes 92^95|0&3, since (56 & 2) yields $0$.
- Now on computing (95 | 0), the expression becomes 92^95&3.
- Further on computing (95 & 3), the expression becomes 92^3.
- Finally (92 ^ 3) yields 95, which is the maximum value of the expression.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
# cook your dish here
def value(a, b, c):
if(c == '&'):
return a&b
elif(c == '^'):
return a^b
elif(c == '|'):
return a|b
def break_rules(n, operator):
if(len(n) == 1):
return n
elif(len(n) == 2):
return [value(n[0], n[1], operator[0])]
else:
cont_ans = []
for i in range(1,len(n)):
l1 = n[:i]
l2 = n[i:]
o1 = operator[:i]
o2 = operator[i:]
l1_ans = break_rules(l1, o1)
l2_ans = break_rules(l2, o2)
for k in l1_ans:
for j in l2_ans:
cont_ans.append(value(k, j, operator[i - 1]))
return cont_ans
t = int(input())
while t > 0 :
operator = []
num = []
exp = input()
temp = ''
for i in range(len(exp)):
if(ord(exp[i]) > 47 and ord(exp[i]) < 58):
temp = temp + exp[i]
else:
num.append(int(temp))
temp = ''
operator.append(exp[i])
if(i == len(exp) - 1):
num.append(int(temp))
t -= 1
# print(num,operator)
print(max(break_rules(num, operator)))
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Today Chef wants to evaluate the dishes of his $N$ students. He asks each one to cook a dish and present it to him.
Chef loves his secret ingredient, and only likes dishes with at least $X$ grams of it.
Given $N$, $X$ and the amount of secret ingredient used by each student $A_i$, find out whether Chef will like at least one dish.
-----Input:-----
- First line will contain $T$, number of testcases. Then the testcases follow.
- The first line of each testcase contains two integers $N$
(number of students) and $X$ (minimum amount of secret ingredient that a dish must contain for Chef to like it).
- The next line contains $N$ space separated integers, $A_i$ denoting the amount of secret ingredient used by the students in their dishes.
-----Output:-----
For each testcase, print a single string "YES" if Chef likes at least one dish. Otherwise, print "NO". (Without quotes).
-----Constraints:-----
- $1 \leq T \leq 100$
- $1 \leq N \leq 1000$
- $1 \leq X \leq 1000000$
- $1 \leq A_i \leq 1000000$
-----Sample Input:-----
3
5 100
11 22 33 44 55
5 50
10 20 30 40 50
5 45
12 24 36 48 60
-----Sample Output:-----
NO
YES
YES
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
t=int(input())
for i in range(t):
n,k=map(int,input().split())
m=list(map(int,input().split()))
a=0
for i in m:
if i>=k:
a=1
break
if a==1:
print('YES')
else:
print('NO')
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Daniel is organizing a football tournament. He has come up with the following tournament format: In the first several (possibly zero) stages, while the number of teams is even, they split in pairs and play one game for each pair. At each stage the loser of each pair is eliminated (there are no draws). Such stages are held while the number of teams is even. Eventually there will be an odd number of teams remaining. If there is one team remaining, it will be declared the winner, and the tournament ends. Otherwise each of the remaining teams will play with each other remaining team once in round robin tournament (if there are x teams, there will be $\frac{x \cdot(x - 1)}{2}$ games), and the tournament ends.
For example, if there were 20 teams initially, they would begin by playing 10 games. So, 10 teams would be eliminated, and the remaining 10 would play 5 games. Then the remaining 5 teams would play 10 games in a round robin tournament. In total there would be 10+5+10=25 games.
Daniel has already booked the stadium for n games. Help him to determine how many teams he should invite so that the tournament needs exactly n games. You should print all possible numbers of teams that will yield exactly n games in ascending order, or -1 if there are no such numbers.
-----Input-----
The first line contains a single integer n (1 ≤ n ≤ 10^18), the number of games that should be played.
Please, do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
-----Output-----
Print all possible numbers of invited teams in ascending order, one per line. If exactly n games cannot be played, output one number: -1.
-----Examples-----
Input
3
Output
3
4
Input
25
Output
20
Input
2
Output
-1
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
n = int(input())
res = set()
for r in range(100):
a = 1
b = 2**(r + 1) - 3
c = -2 * n
d = b * b - 4 * a * c
if d < 0:
continue
le = 0
ri = d
while le < ri:
c = (le + ri) // 2
if c * c < d:
le = c + 1
else:
ri = c
if le * le == d:
if (-b - le) % 4 == 2 and -b - le > 0:
res.add((-b - le) // 2 * 2**r)
if (-b + le) % 4 == 2 and -b + le > 0:
res.add((-b + le) // 2 * 2**r)
for i in sorted(list(res)):
print(i)
if not list(res):
print(-1)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
There are $n$ startups. Startups can be active or acquired. If a startup is acquired, then that means it has exactly one active startup that it is following. An active startup can have arbitrarily many acquired startups that are following it. An active startup cannot follow any other startup.
The following steps happen until there is exactly one active startup. The following sequence of steps takes exactly 1 day. Two distinct active startups $A$, $B$, are chosen uniformly at random. A fair coin is flipped, and with equal probability, $A$ acquires $B$ or $B$ acquires $A$ (i.e. if $A$ acquires $B$, then that means $B$'s state changes from active to acquired, and its starts following $A$). When a startup changes from active to acquired, all of its previously acquired startups become active.
For example, the following scenario can happen: Let's say $A$, $B$ are active startups. $C$, $D$, $E$ are acquired startups under $A$, and $F$, $G$ are acquired startups under $B$: [Image]
Active startups are shown in red.
If $A$ acquires $B$, then the state will be $A$, $F$, $G$ are active startups. $C$, $D$, $E$, $B$ are acquired startups under $A$. $F$ and $G$ have no acquired startups: $G$
If instead, $B$ acquires $A$, then the state will be $B$, $C$, $D$, $E$ are active startups. $F$, $G$, $A$ are acquired startups under $B$. $C$, $D$, $E$ have no acquired startups: [Image]
You are given the initial state of the startups. For each startup, you are told if it is either acquired or active. If it is acquired, you are also given the index of the active startup that it is following.
You're now wondering, what is the expected number of days needed for this process to finish with exactly one active startup at the end.
It can be shown the expected number of days can be written as a rational number $P/Q$, where $P$ and $Q$ are co-prime integers, and $Q \not= 0 \pmod{10^9+7}$. Return the value of $P \cdot Q^{-1}$ modulo $10^9+7$.
-----Input-----
The first line contains a single integer $n$ ($2 \leq n \leq 500$), the number of startups.
The next line will contain $n$ space-separated integers $a_1, a_2, \ldots, a_n$ ($a_i = -1$ or $1 \leq a_i \leq n$). If $a_i = -1$, then that means startup $i$ is active. Otherwise, if $1 \leq a_i \leq n$, then startup $i$ is acquired, and it is currently following startup $a_i$. It is guaranteed if $a_i \not= -1$, then $a_{a_i} =-1$ (that is, all startups that are being followed are active).
-----Output-----
Print a single integer, the expected number of days needed for the process to end with exactly one active startup, modulo $10^9+7$.
-----Examples-----
Input
3
-1 -1 -1
Output
3
Input
2
2 -1
Output
0
Input
40
3 3 -1 -1 4 4 -1 -1 -1 -1 -1 10 10 10 10 10 10 4 20 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 3 3 3 3 3 3 3 3
Output
755808950
-----Note-----
In the first sample, there are three active startups labeled $1$, $2$ and $3$, and zero acquired startups. Here's an example of how one scenario can happen Startup $1$ acquires startup $2$ (This state can be represented by the array $[-1, 1, -1]$) Startup $3$ acquires startup $1$ (This state can be represented by the array $[3, -1, -1]$) Startup $2$ acquires startup $3$ (This state can be represented by the array $[-1, -1, 2]$). Startup $2$ acquires startup $1$ (This state can be represented by the array $[2, -1, 2]$).
At this point, there is only one active startup, and this sequence of steps took $4$ days. It can be shown the expected number of days is $3$.
For the second sample, there is only one active startup, so we need zero days.
For the last sample, remember to take the answer modulo $10^9+7$.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
m = 1000000007
n = int(input())
a = list(map(int, input().split()))
print(pow(2,n-1,m)-1 - sum(pow(2,a.count(x),m)-1 for x in set(a) if x != -1) % m)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Recently Vasya learned that, given two points with different $x$ coordinates, you can draw through them exactly one parabola with equation of type $y = x^2 + bx + c$, where $b$ and $c$ are reals. Let's call such a parabola an $U$-shaped one.
Vasya drew several distinct points with integer coordinates on a plane and then drew an $U$-shaped parabola through each pair of the points that have different $x$ coordinates. The picture became somewhat messy, but Vasya still wants to count how many of the parabolas drawn don't have any drawn point inside their internal area. Help Vasya.
The internal area of an $U$-shaped parabola is the part of the plane that lies strictly above the parabola when the $y$ axis is directed upwards.
-----Input-----
The first line contains a single integer $n$ ($1 \le n \le 100\,000$) — the number of points.
The next $n$ lines describe the points, the $i$-th of them contains two integers $x_i$ and $y_i$ — the coordinates of the $i$-th point. It is guaranteed that all points are distinct and that the coordinates do not exceed $10^6$ by absolute value.
-----Output-----
In the only line print a single integer — the number of $U$-shaped parabolas that pass through at least two of the given points and do not contain any of the given points inside their internal area (excluding the parabola itself).
-----Examples-----
Input
3
-1 0
0 2
1 0
Output
2
Input
5
1 0
1 -1
0 -1
-1 0
-1 -1
Output
1
-----Note-----
On the pictures below all $U$-shaped parabolas that pass through at least two given points are drawn for each of the examples. The $U$-shaped parabolas that do not have any given point inside their internal area are drawn in red. [Image] The first example.
[Image] The second example.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
n = int(input())
rows = [input().split() for _ in range(n)]
rows = [(int(x),int(y)) for x,y in rows]
points = {}
for x,y in rows:
if x in points:
points[x] = max(y, points[x])
else:
points[x] = y
points = sorted(points.items(),key=lambda point: point[0])
def above(p,p1,p2):
"""
x1 < x2
y1 = x1^2 + bx1 + c
y2 = x2^2 + bx2 + c
y >? x^2 + bx + c
y2 - y1 = x2^2 - x1^2 + bx2 - bx1
b = (y2 - y1 - x2^2 + x1^2) / (x2 - x1)
b * (x2 - x1) = y2 - y1 - x2^2 + x1^2
c = y1 - x1^2 - bx1
c * (x2 - x1) = (y1 - x1^2) * (x2 - x1) - x1 * (y2 - y1 - x2^2 + x1^2)
y * (x2 - x1) >? (x^2 + bx + c) * (x2 - x1)
y * (x2 - x1) >?
x^2 * (x2 - x1)
+ x * (y2 - y1 - x2^2 + x1^2)
+ (y1 - x1^2) * (x2 - x1) - x1 * (y2 - y1 - x2^2 + x1^2)
"""
x,y = p
x1,y1 = p1
x2,y2 = p2
x_2 = x**2
x12 = x1**2
x22 = x2**2
x2_x1 = x2 - x1
eq_b = y2 - y1 - x22 + x12
term_y = y * x2_x1
term_x2 = x_2 * x2_x1
term_x = x * eq_b
term_c = (y1 - x12) * x2_x1 - (x1 * eq_b)
return term_y >= term_x2 + term_x + term_c
#print(above(points[2],points[0],points[1]))
Us = []
for i, p in enumerate(points):
while len(Us) >= 2:
p1, p2 = Us[-2:]
if above(p,p1,p2):
Us.pop()
else:
break
Us.append(p)
out = len(Us) - 1
print(out)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
You are given an array $a$ consisting of $n$ integers.
In one move, you can choose some index $i$ ($1 \le i \le n - 2$) and shift the segment $[a_i, a_{i + 1}, a_{i + 2}]$ cyclically to the right (i.e. replace the segment $[a_i, a_{i + 1}, a_{i + 2}]$ with $[a_{i + 2}, a_i, a_{i + 1}]$).
Your task is to sort the initial array by no more than $n^2$ such operations or say that it is impossible to do that.
You have to answer $t$ independent test cases.
-----Input-----
The first line of the input contains one integer $t$ ($1 \le t \le 100$) — the number of test cases. Then $t$ test cases follow.
The first line of the test case contains one integer $n$ ($3 \le n \le 500$) — the length of $a$. The second line of the test case contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \le a_i \le 500$), where $a_i$ is the $i$-th element $a$.
It is guaranteed that the sum of $n$ does not exceed $500$.
-----Output-----
For each test case, print the answer: -1 on the only line if it is impossible to sort the given array using operations described in the problem statement, or the number of operations $ans$ on the first line and $ans$ integers $idx_1, idx_2, \dots, idx_{ans}$ ($1 \le idx_i \le n - 2$), where $idx_i$ is the index of left border of the segment for the $i$-th operation. You should print indices in order of performing operations.
-----Example-----
Input
5
5
1 2 3 4 5
5
5 4 3 2 1
8
8 4 5 2 3 6 7 3
7
5 2 1 6 4 7 3
6
1 2 3 3 6 4
Output
0
6
3 1 3 2 2 3
13
2 1 1 6 4 2 4 3 3 4 4 6 6
-1
4
3 3 4 4
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
t = int(input())
for _ in range(t):
n = int(input())
l = list([int(x)- 1 for x in input().split()])
out = []
ll = [(l[i], i) for i in range(n)]
ll.sort()
swap = (-1,-1)
for i in range(n - 1):
if ll[i][0] == ll[i + 1][0]:
swap = (ll[i][1],ll[i+1][1])
newl = [0]*n
for i in range(n):
newl[ll[i][1]] = i
l = newl
swapN = 0
for i in range(n):
for j in range(i + 1, n):
if l[i] > l[j]:
swapN += 1
#print(l)
if swapN & 1:
l[swap[0]],l[swap[1]] = l[swap[1]],l[swap[0]]
#print(l)
def shift(i):
out.append(i + 1)
l[i],l[i+1],l[i+2] = l[i+2],l[i],l[i+1]
works = True
done = False
while not done:
for i in range(n):
if l[i] != i:
break
else:
done = True
if done:
break
for find in range(i + 1, n):
if l[find] == i:
break
while find - i >= 2:
find -= 2
shift(find)
if find - i == 1:
if find <= n - 2:
shift(find - 1)
shift(find - 1)
else:
works = False
break
#print(l)
if works:
print(len(out))
print(' '.join(map(str,out)))
else:
print(-1)
#print('---')
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Two words rhyme if their last 3 letters are a match. Given N words, print the test case number (of the format Case : num) followed by the rhyming words in separate line adjacent to each other.
The output can be in anyorder.
-----Input-----
First line contains the number of test case T
The next line contains the number of words N
Next N words follow . They’ll contain only alphabets from ‘a’-‘z’.
-----Output-----
Print case number (for each test case) of the format Case : num followed by the words that rhyme in a new line.
-----Constraints-----
1 <= T <= 5
1 <= N <= 1000
3 <= length of each word <= 1000
-----Example-----
Input:
3
3
nope qwerty hope
5
brain drain request grain nest
4
these words dont rhyme
Output:
Case : 1
hope nope
qwerty
Case : 2
brain drain grain
nest request
Case : 3
these
dont
words
rhyme
-----Explanation-----
Case : 2
brain drain grain
nest request
Case : 3
these
dont
words
rhyme
Explanation for case 1: since hope and nope rhyme (suffix “ope” matches), we print them in the same line and qwerty In a new line.
Note that
qwerty
nope hope
is also correct (the output can be in any order )
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
t = int(input())
for i in range(t):
n = int(input())
suffixes = {}
xx = input().split()
for x in range(n):
try:
a = suffixes[xx[x][-3:]]
except Exception as e:
a = []
a.append(xx[x])
suffixes.update({xx[x][-3:]: a})
print("Case : %d" % (i + 1))
for a in sorted(suffixes):
print("".join(b + " " for b in sorted(suffixes[a])).strip())
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Chef is planning a huge party for all of you and has ordered M pizzas. He wants to invite as many people to the party. However, he knows that everyone will have exactly one slice of a pizza (regardless of the size) and he wants to make sure that he has enough pizza slices.
Chef is very lazy and will only make a total of N straight cuts among all the pizzas. Each pizza is also of different size and to avoid the slices getting too small the chef can only make a max of Ai cuts to the ith pizza. He wants to maximize the number of slices of pizza. Since chef is busy with preparing other aspects of the party he wants you to find out the maximum number of slices he can get following the constraints.
If a pizza is not cut at all then it is considered as 1 slice.
-----Input-----
First line contains two integers M and N.
The second line of input contains the array A.
-----Output-----
Output a single integer - the maximum number of slices chef can get.
-----Constraints-----
- 1 ≤ M ≤ 2*105
- 1 ≤ N,Ai ≤ 2*105
-----Subtasks-----
- Subtask 1: 1 ≤ M,N ≤ 100 - 10 points
- Subtask 2: 1 ≤ N ≤ 100,
1 ≤ M ≤ 105 - 20 points
- Subtask 3: Original Constraints - 70 points
-----Example-----
Input:
5 10
1 2 3 4 5
Output:
31
-----Explanation-----
Example case 1. One of the optimal way to cut would be to do {0, 1, 0, 4, 5} cuts.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
# cook your dish here
m,n=[int(i) for i in input().split()]
arr=list(map(int,input().split()))
arr=sorted(arr,reverse=True)
ans=0
w=0
q=m
for m in range(q):
if(arr[m]>n):
w=1
break
ans+=1+(arr[m]*(arr[m]+1))//2
n-=arr[m]
if(n==0):
print(ans)
else:
if(w==1):
print(ans+q-m+(n*(n+1))//2)
else:
print(ans)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Given an alphanumeric string made up of digits and lower case Latin characters only, find the sum of all the digit characters in the string.
-----Input-----
- The first line of the input contains an integer T denoting the number of test cases. Then T test cases follow.
- Each test case is described with a single line containing a string S, the alphanumeric string.
-----Output-----
- For each test case, output a single line containing the sum of all the digit characters in that string.
-----Constraints-----
- 1 ≤ T ≤ 1000
- 1 ≤ |S| ≤ 1000, where |S| is the length of the string S.
-----Example-----
Input:
1
ab1231da
Output:
7
-----Explanation-----
The digits in this string are 1, 2, 3 and 1. Hence, the sum of all of them is 7.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
for _ in range(eval(input())):
s = input()
ans = 0
for i in s:
if i.isdigit():
ans += int(i)
print(ans)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Chef is baking a cake.
While baking, in each minute the size of cake doubles as compared to its previous size.
In this cake, baking of cake is directly proportional to its size.
You are given $a$, the total time taken(in minutes) to bake the whole cake.
Let cake be half baked at $k^{th}$ minute.
Your task is to find the value of $k+2$.
-----Input:-----
- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of T test cases follows.
- The first and only line of each test case contains a single integer $a$.
-----Output:-----
For each testcase , print one line, the value of $k+2$.
-----Constraints-----
- $1 \leq T \leq 8 $
- $2 \leq a \leq 10^{128}$
-----Sample Input:-----
1
2
-----Sample Output:-----
3
-----Explaination-----
Time was 1 min when cake was half baked by chef so answer is 1+2=3
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
# cook your dish here
for _ in range(int(input())):
a=int(input())
print(a/2+2)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Catherine received an array of integers as a gift for March 8. Eventually she grew bored with it, and she started calculated various useless characteristics for it. She succeeded to do it for each one she came up with. But when she came up with another one — xor of all pairwise sums of elements in the array, she realized that she couldn't compute it for a very large array, thus she asked for your help. Can you do it? Formally, you need to compute
$$ (a_1 + a_2) \oplus (a_1 + a_3) \oplus \ldots \oplus (a_1 + a_n) \\ \oplus (a_2 + a_3) \oplus \ldots \oplus (a_2 + a_n) \\ \ldots \\ \oplus (a_{n-1} + a_n) \\ $$
Here $x \oplus y$ is a bitwise XOR operation (i.e. $x$ ^ $y$ in many modern programming languages). You can read about it in Wikipedia: https://en.wikipedia.org/wiki/Exclusive_or#Bitwise_operation.
-----Input-----
The first line contains a single integer $n$ ($2 \leq n \leq 400\,000$) — the number of integers in the array.
The second line contains integers $a_1, a_2, \ldots, a_n$ ($1 \leq a_i \leq 10^7$).
-----Output-----
Print a single integer — xor of all pairwise sums of integers in the given array.
-----Examples-----
Input
2
1 2
Output
3
Input
3
1 2 3
Output
2
-----Note-----
In the first sample case there is only one sum $1 + 2 = 3$.
In the second sample case there are three sums: $1 + 2 = 3$, $1 + 3 = 4$, $2 + 3 = 5$. In binary they are represented as $011_2 \oplus 100_2 \oplus 101_2 = 010_2$, thus the answer is 2.
$\oplus$ is the bitwise xor operation. To define $x \oplus y$, consider binary representations of integers $x$ and $y$. We put the $i$-th bit of the result to be 1 when exactly one of the $i$-th bits of $x$ and $y$ is 1. Otherwise, the $i$-th bit of the result is put to be 0. For example, $0101_2 \, \oplus \, 0011_2 = 0110_2$.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
import sys
input = sys.stdin.readline
n = int(input())
a = list(map(int, input().split()))
b = a
ans = 0
for k in range(29):
a0 = []
a1 = []
a0a = a0.append
a1a = a1.append
b0 = []
b1 = []
b0a = b0.append
b1a = b1.append
for i in a:
if i&(1<<k): a1a(i)
else: a0a(i)
for i in b:
if i&(1<<k): b1a(i)
else: b0a(i)
a = a0+a1
b = b0+b1
mask = (1<<(k+1))-1
aa = [i&mask for i in a]
bb = [i&mask for i in b]
res = 0
p1 = 1<<k
p2 = mask+1
p3 = p1+p2
j1 = j2 = j3 = 0
for jj, ai in enumerate(reversed(aa)):
while j1 < n and ai+bb[j1] < p1:
j1 += 1
while j2 < n and ai+bb[j2] < p2:
j2 += 1
while j3 < n and ai+bb[j3] < p3:
j3 += 1
res += max(n, n - jj) - max(j3, n - jj)
res += max(j2, n - jj) - max(j1, n - jj)
ans |= (res & 1) << k
print(ans)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
The Government of Siruseri is no different from any other when it comes to being "capital-centric" in its policies. Recently the government decided to set up a nationwide fiber-optic network to take Siruseri into the digital age. And as usual, this decision was implemented in a capital centric manner --- from each city in the country, a fiber optic cable was laid to the capital! Thus, traffic between any two cities had to go through the capital.
Soon, it became apparent that this was not quite a clever idea, since any breakdown at the capital resulted in the disconnection of services between other cities. So, in the second phase, the government plans to connect a few more pairs of cities directly by fiber-optic cables. The government has specified that this is to be done in such a way that the disruption of services at any one city will still leave the rest of the country connected.
The government has data on the cost of laying fiber optic cables between every pair of cities. You task is to compute the minimum cost of additional cabling required to ensure the requirement described above is met.
For example, if Siruseri has $4$ cities numbered $1,2,3$ and $4$ where $1$ is the capital and further suppose that the cost of laying cables between these cities are as given in the table below:
Note that the government has already connected the capital with every other city. So, if we connect the cities $2$ and $3$ as well as $3$ and $4$, you can check that disruption of service at any one city will still leave the other cities connected. The cost of connecting these two pairs is $4 + 6 = 10$. The same effect could have been achieved by connecting $2$ and $3$ as well as $2$ and $4$, which would have cost $4 + 5 = 9$. You can check that this is the best you can do.
Your task is to write a program that allows the government to determine the minimum cost it has to incur in laying additional cables to fulfil the requirement.
-----Input:-----
- The first line of the input contains a single integer $N$ indicating the number of cities in Siruseri. You may assume that the capital city is always numbered $1$.
- This is followed by $N$ lines of input each containing $N$ integers.
- The $j^{th}$ integer on line $i$ is the cost of connecting city $i$ with city $j$. The $j^{th}$ integer on line $i$ will be the same as the $i^{th}$ integer on line $j$ (since the links are bidirectional) and the $i^{th}$ entry on line $i$ will always be $0$ (there is no cost in connecting a city with itself).
-----Output:-----
A single integer indicating the minimum total cost of the links to be added to ensure that disruption of services at one city does not disconnect the rest of the cities.
-----Constraints:-----
- $1 \leq N \leq 2000$.
- $0 \leq$ costs given in the input $\leq 100000$
-----Sample Input-----
4
0 7 8 10
7 0 4 5
8 4 0 6
10 5 6 0
-----Sample Output-----
9
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
n=int(input())
l=[]
for i in range(n):
l.append([int(x) for x in input().split()])
d=[10**9]*(n)
q=set([int(x) for x in range(1,n)])
d[1]=0
#print(q)
def extract():
mini=10**9
o=0
for i in range(1,len(d)):
if d[i]<mini and i in q:
mini=d[i]
o=i
q.remove(o)
return o
while len(q)!=0:
x=extract()
for i in range(1,n):
if i in q and l[x][i]<d[i]:
d[i]=l[x][i]
print(sum(d[1:]))
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Chef and his best friend Aleksa are into mathematical games these days. Today, they have some ( ≥ 0 ) black cells represented as B, and a white cell represented as W, lying randomly in a straight line.
They have decided to play with these cells. In a move, a player chooses some ( > 0 ) black cells lying on any one side of the white cell and remove them. It should be noted that a player is not allowed to choose black cells from both side of the given white cell. Both the players alternate their moves, and play optimally. The player who is unable to move in his respective turn will lose the game.
Aleksa, being a girl, has a habit of playing first. But Chef is fairly smart himself, and will not play the game if he is going to lose it. Therefore, he wants to know the winner beforehand. Can you tell him who is going to win the game for the given configuration of cells?
-----Input-----
First line of input contains a single integer T denoting the number of test cases. First and the only line of each test case contains a string S consisting of the characters 'B' and 'W', denoting black and white cells, respectively.
-----Output-----
For each test case, output "Chef" if chef wins the game for the given configuration. Else print "Aleksa". (quotes for clarity only).
-----Constraints-----
- 1 ≤ T ≤ 10
- 1 ≤ |S| ≤ 10000
- S contains exactly 1 white cell.
-----Scoring-----
- Subtask 1: 1 ≤ T ≤ 10, 1 ≤ |S| ≤ 10 : ( 30 pts )
- Subtask 2: 1 ≤ T ≤ 10, 1 ≤ |S| ≤ 100 : ( 30 pts )
- Subtask 3: 1 ≤ T ≤ 10, 1 ≤ |S| ≤ 10000 : ( 40 pts )
-----Example-----
Input
3
W
BW
BWBB
Output
Chef
Aleksa
Aleksa
----- Explanation-----
- Test 1 : Aleksa cannot make a move in her first turn as there is no black cell in the given configuration.
- Test 2 : Aleksa can remove 1 black cell lying on the left of white cell in her turn. But then, Chef cannot make a move in his turn as there will be no black cells left.
- Test 3 : Figure out yourself.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
t =int(input()) #no. of test cases
while t>0:
t=t-1
str=input()
size=len(str)
pos=str.find('W')
left=pos
right=size-pos-1
arr = [[0 for i in range(right+1)] for j in range(left+1)]
#arr[i,j] = 1 if with i black cells on left and j on right 1st player can win, 0 otherwise.
#Recursion: arr[i][j]= or(arr[x][y])
arr[0][0]=0
for i in range(left+1):
for j in range(right+1):
if i==j:
arr[i][j]=0
else:
arr[i][j]=1
if(arr[left][right]==1):
print("Aleksa")
else:
print("Chef")
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
You're given an integer N. Write a program to calculate the sum of all the digits of N.
-----Input-----
The first line contains an integer T, the total number of testcases. Then follow T lines, each line contains an integer N.
-----Output-----
For each test case, calculate the sum of digits of N, and display it in a new line.
-----Constraints-----
- 1 ≤ T ≤ 1000
- 1 ≤ N ≤ 1000000
-----Example-----
Input
3
12345
31203
2123
Output
15
9
8
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
# cook your dish here
number = int(input())
for i in range(number):
a = list(input())
for k in range(len(a)):
a[k] = eval(a[k])
print(sum(a))
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
You are given an array with $N$ integers: $A[1], A[2], \ldots, A[N]$ (where $N$ is even). You are allowed to permute the elements however you want. Say, after permuting the elements, you end up with the array $A'[1], A'[2], \ldots, A'[N]$. Your goal is to maximize the following sum:
|A′[1]−A′[2]| + |A′[3]−A′[4]| + ... + |A′[N−1]−A′[N]||A′[1]−A′[2]| + |A′[3]−A′[4]| + ... + |A′[N−1]−A′[N]|
|A'[1] - A'[2]| \ + \ |A'[3] - A'[4]| \ + \ ... \ + \ |A'[N - 1] - A'[N]|
Here, $|x|$ denotes the absolute value of $x$.
You have to print the maximum sum achievable.
-----Input-----
- The first line contains $T$, the number of test cases.
- Each test case starts with an integer $N$ in the first line.
- The second line of each test case contains $N$ space separated integers, denoting the values of array $A$.
-----Output-----
For each test case, output the maximum sum achievable in a new line.
-----Constraints-----
- $1 \le T \le 10^5$
- $1 \le N \le 10^5$
- $N$ is even
- $|A[i]| \le 10^9$
- Sum of $N$ over all test cases $\le 2 * 10^5$
-----Example Input 1-----
1
4
1 -3 2 -3
-----Example Output 1-----
9
-----Explanation 1-----
The original array is {$1, -3, 2, -3$}. Suppose you permute it and get the array {$2, 1, -3, -3$}. Then the corresponding sum would be $|2 - 1| \ + \ |-3 - (-3)| = 1 + 0 = 1$.
But suppose you permute it differently and get the array {$-3, 2, 1, -3$}. Then the corresponding sum would be $|-3 - 2| \ + \ |1 - (-3)| = 5 + 4 = 9$. You can check that you cannot do any better, and hence the answer is 9.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
for i in range(int(input())):
n=int(input())
m=list(map(int,input().split()))[:n]
m.sort()
t=0
for j in range(n//2):
t+=abs(m[j]-m[n-j-1])
print(t)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Vasya claims that he had a paper square. He cut it into two rectangular parts using one vertical or horizontal cut. Then Vasya informed you the dimensions of these two rectangular parts. You need to check whether Vasya originally had a square. In other words, check if it is possible to make a square using two given rectangles.
-----Input-----
The first line contains an integer $t$ ($1 \le t \le 10^4$) — the number of test cases in the input. Then $t$ test cases follow.
Each test case is given in two lines.
The first line contains two integers $a_1$ and $b_1$ ($1 \le a_1, b_1 \le 100$) — the dimensions of the first one obtained after cutting rectangle. The sizes are given in random order (that is, it is not known which of the numbers is the width, and which of the numbers is the length).
The second line contains two integers $a_2$ and $b_2$ ($1 \le a_2, b_2 \le 100$) — the dimensions of the second obtained after cutting rectangle. The sizes are given in random order (that is, it is not known which of the numbers is the width, and which of the numbers is the length).
-----Output-----
Print $t$ answers, each of which is a string "YES" (in the case of a positive answer) or "NO" (in the case of a negative answer). The letters in words can be printed in any case (upper or lower).
-----Example-----
Input
3
2 3
3 1
3 2
1 3
3 3
1 3
Output
Yes
Yes
No
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
for _ in range(int(input())):
a1, b1 = list(map(int, input().split()))
a2, b2 = list(map(int, input().split()))
if a1 > b1:
a1, b1 = b1, a1
if a2 > b2:
a2, b2 = b2, a2
flag = False
if a1 == a2 and a1 == b1 + b2:
flag = True
if b1 == b2 and b1 == a1 + a2:
flag = True
print('Yes' if flag else 'No')
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Well known investigative reporter Kim "Sherlock'' Bumjun needs your help! Today, his mission is to sabotage the operations of the evil JSA. If the JSA is allowed to succeed, they will use the combined power of the WQS binary search and the UFDS to take over the world!
But Kim doesn't know where the base is located. He knows that the base is on the highest peak of the Himalayan Mountains. He also knows the heights of each of the $N$ mountains. Can you help Kim find the height of the mountain where the base is located?
-----Input:-----
- First line will contain $T$, number of testcases. Then the testcases follow.
- The first line in each testcase contains one integer, $N$.
- The following $N$ lines of each test case each contain one integer: the height of a new mountain.
-----Output:-----
For each testcase, output one line with one integer: the height of the tallest mountain for that test case.
-----Constraints-----
- $1 \leq T \leq 10$
- $1 \leq N \leq 100000$
- $0 \leq$ height of each mountain $\leq 10^9$
-----Subtasks:-----
- 100 points: No additional constraints.
-----Sample Input:-----
1
5
4
7
6
3
1
-----Sample Output:-----
7
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
n=int(input())
def do():
t=int(input())
x=[]
for i in range(t):
x.append(int(input()))
print(max(x))
return
for i in range(n):
do()
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Accepts a string from the user and print the reverse string as the output without using any built-in function.
-----Input:-----
Each testcase contains of a single line of input, a string.
-----Output:-----
For each testcase, output in a single line answer, the reverse string.
-----Sample Input:-----
1
Tracy
-----Sample Output:-----
ycarT
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
oo = int(input())
for i in range(oo):
val = input()
print(val[::-1])
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Bobby has decided to hunt some Parrots. There are n horizontal branch of trees aligned parallel to each other. Branches are numbered 1 to n from top to bottom. On each branch there are some parrots sitting next to each other. Supposed there are a[i]$a[i]$ parrots sitting on the i−th$ i-th$ branch.
Sometimes Bobby shots one of the parrot and the parrot dies (suppose that this parrots sat at the i−th$i-th$ branch). Consequently all the parrots on the i−th$i-th$ branch to the left of the dead parrot get scared and jump up on the branch number i − 1$i - 1$, if there exists no upper branch they fly away. Also all the parrots to the right of the dead parrot jump down on branch number i + 1$i + 1$, if there exists no such branch they fly away.
Bobby has shot m parrots. You're given the initial number of parrots on each branch, tell him how many parrots are sitting on each branch after the shots.
-----Input:-----
The first line of the input contains an integer N$N$. The next line contains a list of space-separated integers a1, a2, …, an.
The third line contains an integer M$M$. Each of the next M$M$ lines contains two integers x[i]$x[i]$ and y[i]$y[i]$. The integers mean that for the i-th time Bobby shoot the y[i]-th (from left) parrot on the x[i]-th branch. It's guaranteed there will be at least y[i] parrot on the x[i]-th branch at that moment.
-----Output:-----
On the i−th$i-th$ line of the output print the number of parrots on the i−th$i-th$ branch.
-----Constraints-----
- 1≤N≤100$1 \leq N \leq 100$
- 0≤a[i]≤100$0 \leq a[i] \leq 100$
- 0≤M≤100$0 \leq M \leq 100$
- 1≤x[i]≤n$1 \leq x[i] \leq n$, 1≤y[i]$1 \leq y[i] $
-----Sample Input:-----
5
10 10 10 10 10
5
2 5
3 13
2 12
1 13
4 6
3
2 4 1
1
2 2
-----Sample Output:-----
0
12
5
0
16
3
0
3
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
n = int(input())
x = [int(i) for i in input().split()]
m = int(input())
for i in range(m):
a,b = map(int,input().split())
a -= 1
t = b-1
t1 = x[a]-b
if a-1>=0:
x[a-1] += t
if a+1<n:
x[a+1] += t1
x[a] = 0
for i in x:
print(i)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
You are given a tree (connected graph without cycles) consisting of $n$ vertices. The tree is unrooted — it is just a connected undirected graph without cycles.
In one move, you can choose exactly $k$ leaves (leaf is such a vertex that is connected to only one another vertex) connected to the same vertex and remove them with edges incident to them. I.e. you choose such leaves $u_1, u_2, \dots, u_k$ that there are edges $(u_1, v)$, $(u_2, v)$, $\dots$, $(u_k, v)$ and remove these leaves and these edges.
Your task is to find the maximum number of moves you can perform if you remove leaves optimally.
You have to answer $t$ independent test cases.
-----Input-----
The first line of the input contains one integer $t$ ($1 \le t \le 2 \cdot 10^4$) — the number of test cases. Then $t$ test cases follow.
The first line of the test case contains two integers $n$ and $k$ ($2 \le n \le 2 \cdot 10^5$; $1 \le k < n$) — the number of vertices in the tree and the number of leaves you remove in one move, respectively. The next $n-1$ lines describe edges. The $i$-th edge is represented as two integers $x_i$ and $y_i$ ($1 \le x_i, y_i \le n$), where $x_i$ and $y_i$ are vertices the $i$-th edge connects. It is guaranteed that the given set of edges forms a tree.
It is guaranteed that the sum of $n$ does not exceed $2 \cdot 10^5$ ($\sum n \le 2 \cdot 10^5$).
-----Output-----
For each test case, print the answer — the maximum number of moves you can perform if you remove leaves optimally.
-----Example-----
Input
4
8 3
1 2
1 5
7 6
6 8
3 1
6 4
6 1
10 3
1 2
1 10
2 3
1 5
1 6
2 4
7 10
10 9
8 10
7 2
3 1
4 5
3 6
7 4
1 2
1 4
5 1
1 2
2 3
4 3
5 3
Output
2
3
3
4
-----Note-----
The picture corresponding to the first test case of the example:
[Image]
There you can remove vertices $2$, $5$ and $3$ during the first move and vertices $1$, $7$ and $4$ during the second move.
The picture corresponding to the second test case of the example:
[Image]
There you can remove vertices $7$, $8$ and $9$ during the first move, then vertices $5$, $6$ and $10$ during the second move and vertices $1$, $3$ and $4$ during the third move.
The picture corresponding to the third test case of the example:
$\text{of}$
There you can remove vertices $5$ and $7$ during the first move, then vertices $2$ and $4$ during the second move and vertices $1$ and $6$ during the third move.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
from bisect import bisect_left as bl
from bisect import bisect_right as br
from heapq import heappush,heappop,heapify
import math
from collections import *
from functools import reduce,cmp_to_key
import sys
input = sys.stdin.readline
M = mod = 998244353
def factors(n):return sorted(set(reduce(list.__add__, ([i, n//i] for i in range(1, int(n**0.5) + 1) if n % i == 0))))
def inv_mod(n):return pow(n, mod - 2, mod)
def li():return [int(i) for i in input().rstrip('\n').split()]
def st():return input().rstrip('\n')
def val():return int(input().rstrip('\n'))
def li2():return [i for i in input().rstrip('\n')]
def li3():return [int(i) for i in input().rstrip('\n')]
for _ in range(val()):
n, k = li()
d = defaultdict(set)
for i in range(n-1):
a, b = li()
d[a].add(b)
d[b].add(a)
thistime = 1
he = deque()
visited = {}
for i in d:
if len(d[i]) == 1:
visited[i] = 1
he.append(i)
ans = 0
counts = defaultdict(int)
# print(he)
while he:
i = he.popleft()
for j in list(d[i]):
counts[j] += 1
d[i].remove(j)
d[j].remove(i)
if counts[j] == k:
thistime = 1
ans += 1
counts[j] = 0
if len(d[j]) == 1:
if j not in visited:he.append(j)
visited[j] = 1
# print(j, he)
print(ans)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Polygon is not only the best platform for developing problems but also a square matrix with side $n$, initially filled with the character 0.
On the polygon, military training was held. The soldiers placed a cannon above each cell in the first row and a cannon to the left of each cell in the first column. Thus, exactly $2n$ cannons were placed. [Image] Initial polygon for $n=4$.
Cannons shoot character 1. At any moment of time, no more than one cannon is shooting. When a 1 flies out of a cannon, it flies forward (in the direction of the shot) until it collides with a polygon border or another 1. After that, it takes the cell in which it was before the collision and remains there. Take a look at the examples for better understanding.
More formally: if a cannon stands in the row $i$, to the left of the first column, and shoots with a 1, then the 1 starts its flight from the cell ($i, 1$) and ends in some cell ($i, j$); if a cannon stands in the column $j$, above the first row, and shoots with a 1, then the 1 starts its flight from the cell ($1, j$) and ends in some cell ($i, j$).
For example, consider the following sequence of shots: [Image]
1. Shoot the cannon in the row $2$. 2. Shoot the cannon in the row $2$. 3. Shoot the cannon in column $3$.
You have a report from the military training on your desk. This report is a square matrix with side length $n$ consisting of 0 and 1. You wonder if the training actually happened. In other words, is there a sequence of shots such that, after the training, you get the given matrix?
Each cannon can make an arbitrary number of shots. Before the training, each cell of the polygon contains 0.
-----Input-----
The first line contains an integer $t$ ($1 \le t \le 1000$) — the number of test cases. Then $t$ test cases follow.
Each test case starts with a line containing an integer $n$ ($1 \le n \le 50$) — the size of the polygon.
This is followed by $n$ lines of length $n$, consisting of 0 and 1 — the polygon matrix after the training.
The total area of the matrices in all test cases in one test does not exceed $10^5$.
-----Output-----
For each test case print: YES if there is a sequence of shots leading to a given matrix; NO if such a sequence does not exist.
The letters in the words YES and NO can be printed in any case.
-----Example-----
Input
5
4
0010
0011
0000
0000
2
10
01
2
00
00
4
0101
1111
0101
0111
4
0100
1110
0101
0111
Output
YES
NO
YES
YES
NO
-----Note-----
The first test case was explained in the statement.
The answer to the second test case is NO, since a 1 in a cell ($1, 1$) flying out of any cannon would continue its flight further.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
def read_int():
return int(input())
def read_ints():
return list(map(int, input().split(' ')))
t = read_int()
for case_num in range(t):
n = read_int()
mat = []
for i in range(n):
mat.append(input())
ok = True
for i in range(n):
for j in range(n):
if mat[i][j] == '0':
continue
cok = j == n - 1 or i == n - 1
if not cok:
cok = mat[i][j + 1] == '1' or mat[i + 1][j] == '1'
if not cok:
ok = False
break
if not ok:
break
print('YES' if ok else 'NO')
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
The Siruseri amusement park has a new attraction. It consists of a rectangular array of discs. Each disc is divided into four equal sectors and the four sectors are coloured with the colours Red, Blue, Green and Yellow (in some order). The ordering may be different in different discs. Here is a possible arrangment of the discs:
You start at the top left disc. Your task is to walk down to the bottom right disc. In each step, you can rotate the current disc by $90$ degrees in the clockwise direction or move to a neighbouring disc. However, you can move to a neighbouring disc only if adjacent sectors of these two discs have the same colour. For example, in the figure above, you can move from the disc at position ($1$, $1$) to either of its neighbours. However, from the disc at position ($1$, $2$) you can only move to the disc at position ($1$, $1$). If you wish to move from ($1$, $2$) to ($1$, $3$) then you would have to rotate this disc three times so that the colour (red) on the adjacent sectors are the same.
For each rotate move, a penalty point is added to the score. The aim is to reach the bottom right with as few penalty points as possible. For example, in the arrangement described in the above figure, the best possible score is $2$, corresponding to the following path: Move from ($1$, $1$) to ($2$, $1$). Move from ($2$, $1$) to ($2$, $2$). Rotate. Rotate. Move from ($2$, $2$) to ($2$, $3$). Move from ($2$, $3$) to ($1$, $3$). Move from ($1$, $3$) to ($1$, $4$). Finally, move from ($1$, $4$) to ($2$, $4$).
Your task is to determine the minimum number of penalty points required to go from the top left disc to the bottom right disc for the given arrangement of discs.
-----Input:-----
The first line contains two integers $M$ and $N$. $M$ is the number of rows and $N$ is the number of columns in the given arrangment. This is followed by $M \times N$ lines of input. Lines $2$ to $N+1$, describe the colours on the discs on the first row, Lines $N+2$ to $2 \cdot N+1$ describe the colours on discs in the second row and so on. Each of these lines contain a permutation of the set {R, G, B, Y} giving the colours in the top, right, bottom and left sectors in that order.
-----Output:-----
A single integer on a single line indicating the minimum number of penalty points required to go from the top left disc to the bottom right disc for the given arrangement of discs.
-----Constraints:-----
- In $80 \%$ of the input, $1 \leq M,N \leq 60$.
- In all the inputs $1 \leq M,N \leq 1000$.
-----Sample Input-----
2 4
G Y B R
B G R Y
G Y B R
G R B Y
B Y G R
G B R Y
B R G Y
B R G Y
-----Sample Output-----
2
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
#for _ in range(int(input()):
#n,m = map(int,input().split())
#x = [int(w) for w in input().split()]
#n = int(input())
#x = [int(input()) for _ in range(n)]
#for i in range(n):
#dt = {} for i in x:dt[i] = dt.get(i,0)+1
#dt = {k:v for k,v in sorted(x.items(), key=lambda i: i[1])}
m,n = map(int,input().split()) # top,right,bottom,left
x = []
for i in range(m):
x.append([])
for j in range(n):
clr = [w for w in input().split()]
x[i].append(clr)
import queue as Q
dp = [float('inf')]*m
for i in range(m):
dp[i] = [float('inf')]*n
dp[m-1][n-1] = 0
pq = Q.PriorityQueue()
pq.put([dp[m-1][n-1],m-1,n-1])
visited = set()
xx,yy = [-1,0,1,0],[0,1,0,-1] # top,right,bottom,left
while not pq.empty():
pop = pq.get()
cx,cy = pop[1],pop[2]
if (cx,cy) not in visited:
visited.add((cx,cy))
for k in range(4):
nx,ny = cx+xx[k],cy+yy[k]
if 0<=nx<m and 0<=ny<n and (nx,ny) not in visited:
clr = x[cx][cy][k]
#print("*",nx,ny,"_",k,clr)
ind = x[nx][ny].index(clr)
cost = (k-(ind+2)%4)%4
#print(cost)
if dp[cx][cy]+cost < dp[nx][ny]:
dp[nx][ny] = dp[cx][cy]+cost
pq.put([dp[nx][ny],nx,ny])
#print("#############")
#print(dp)
print(dp[0][0])
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Mr. Pr and Ms. Ad are at $a$ and $b$ respectively on an infinite number line. Mr. Pr wants to meet Ms. Ad.
Mr. Pr can choose to move $c$ or $d$ units in 1 second. If Mr. Pr moves $c$ units then Ms. Ad will move $d$ units and vice versa. (Both of them always moved in positive x-direction)
You have to determine if Mr. Pr can meet with Ms. Ad after some integral amount of time, given that Mr. Pr chooses optimally. Note that meeting after a fractional amount of time does not count.
-----Input:-----
- First line will contain $T$, number of testcases. Then the testcases follow.
- Each testcase contains four space separated integers, $a$, $b$, $c$, and $d$.
-----Output:-----
- For each test case, output a single line containing "YES" if Mr. Pr meets with Ms. Ad, otherwise "NO".
-----Constraints-----
- $1 \leq T \leq 10^5$
- $1 \leq a,b,c,d \leq 10^9$
-----Sample Input:-----
2
3 4 1 2
10 20 3 7
-----Sample Output:-----
YES
NO
-----Explanation:-----
In the first test case, Mr. Pr will move 2 units in the first second and Ms. Ad moves 1 unit simultaneously and they meet.
In the second test case, it is impossible to meet (fractional time is not allowed).
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
for _ in range(int(input())):
a,b,c,d=list(map(int,input().split()))
if(a==b):
print('YES')
elif(c==d):
print('NO')
else:
if(abs(a-b)%abs(c-d)==0):
print('YES')
else:
print('NO')
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
You are given a sequence $A_1, A_2, \ldots, A_N$. You have to split the array into maximum number of non-empty subarrays such that the gcd of elements of each subarray is equal to 1.
-----Input:-----
- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
- The first line of each test case contains a single integer $N$.
- The second line contains $N$ space-separated integers $A_1, A_2, \ldots, A_N$.
-----Output:-----
For each test case, print a single line containing one integer ― the maximum number of subarrays formed, or $-1$ if the array cannot be split while satisfying the above condition.
-----Constraints-----
- $1 \le T \le 3$
- $1 \le N \le 5 \cdot 10^5$
- $1 \le A_i \le 10^6$ for each valid $i$
-----Sample Input:-----
2
3
2 2 3
4
2 3 3 2
-----Sample Output:-----
1
2
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
'''input
2
3
2 2 3
4
2 3 3 2
'''
import math
for _ in range(int(input())):
n = int(input())
a = list(map(int, input().split()))
count = 0
i = 0
while i < len(a):
if a[i] == 1:
count += 1
i += 1
continue
curr_gcd = a[i]
while i < len(a) and curr_gcd != 1:
curr_gcd = math.gcd(curr_gcd, a[i])
if curr_gcd == 1:
count += 1
i += 1
# print(i)
break
i += 1
print(count)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
The chef is trying to decode some pattern problems, Chef wants your help to code it. Chef has one number K to form a new pattern. Help the chef to code this pattern problem.
-----Input:-----
- First-line will contain $T$, the number of test cases. Then the test cases follow.
- Each test case contains a single line of input, one integer $K$.
-----Output:-----
For each test case, output as the pattern.
-----Constraints-----
- $1 \leq T \leq 100$
- $1 \leq K \leq 100$
-----Sample Input:-----
4
1
2
3
4
-----Sample Output:-----
2
23
34
234
345
456
2345
3456
4567
5678
-----EXPLANATION:-----
No need, else pattern can be decode easily.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
try:
tc=int(input())
for _ in range(tc):
n=int(input())
st=""
b=1
for i in range(1,n+1):
b+=1
a=b
for j in range(1,n+1):
print(a,end='')
a+=1
print()
except:
pass
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
You are given two integers $N$ and $M$. Find the number of sequences $A_1, A_2, \ldots, A_N$, where each element is an integer between $1$ and $M$ (inclusive) and no three consecutive elements are equal. Since this number could be very large, compute it modulo $10^9+7$.
-----Input-----
- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
- The first and only line of each test case contains two space-separated integers $N$ and $M$.
-----Output-----
For each test case, print a single line containing one integer ― the number of valid sequences modulo $10^9+7$.
-----Constraints-----
- $1 \le T \le 10^5$
- $1 \le N, M \le 10^{18}$
-----Subtasks-----
Subtask #1 (50 points):
- $T \le 20$
- $N \le 10^5$
Subtask #2 (50 points): original constraints
-----Example Input-----
2
2 2
3 4
-----Example Output-----
4
60
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
import sys
def fin(): return sys.stdin.readline().strip()
def fout(s, end="\n"): sys.stdout.write(str(s)+end)
MOD = pow(10, 9)+7
t = int(input())
while t>0:
t -= 1
n, m = list(map(int, fin().split()))
if n == 1:
print(m%MOD)
continue
dp1 = m*(m-1)
dp2 = m
for i in range(3, n+1):
temp = dp2
dp2 = dp1
dp1 = (temp*(m-1))%MOD+(dp1*(m-1))%MOD
print((dp1+dp2)%MOD)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Chef just got a box of chocolates as his birthday gift. The box contains $N$ chocolates in a row (numbered $1$ through $N$), where $N$ is even. For each valid $i$, the $i$-th chocolate has a sweetness value $W_i$.
Chef wants to eat all the chocolates in the first half of the box and leave all chocolates in the second half uneaten. Since he does not like chocolates that are too sweet, he will be unhappy if at least one of the chocolates he eats has the maximum sweetness among all the chocolates in the box.
A right cyclic shift by $k$ chocolates ($0 \le k < N$) consists of moving the last $k$ chocolates in the row to the beginning in the same order and moving each of the remaining $N-k$ chocolates $k$ places to the right. Before eating the first half of the chocolates, Chef wants to perform some right cyclic shift in such a way that he will not be unhappy after eating them. Find the number of ways to do this, i.e. the number of valid integers $k$ such that if Chef performs the right cyclic shift by $k$ chocolates and then eats the first half of the chocolates in the box, he does not become unhappy.
-----Input-----
- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
- The first line of each test case contains a single integer $N$.
- The second line contains $N$ space-separated integers $W_1, W_2, \ldots, W_N$.
-----Output-----
For each test case, print a single line containing one integer ― the number of shifts for which Chef does not become unhappy.
-----Constraints-----
- $1 \le T \le 5$
- $1 \le N \le 10^5$
- $N$ is even
- $1 \le W_i \le 10^5$ for each valid $i$
-----Example Input-----
2
6
1 1 2 1 1 1
6
1 1 2 1 1 2
-----Example Output-----
3
0
-----Explanation-----
Example case 1: The three valid right shifts and the contents of the box for these shifts are:
- shift by $k = 1$: $(1, 1, 1, 2, 1, 1)$
- shift by $k = 2$: $(1, 1, 1, 1, 2, 1)$
- shift by $k = 3$: $(1, 1, 1, 1, 1, 2)$
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
from collections import deque
t=int(input())
for i in range(t):
n=int(input())
N=[i for i in range(1, n+1)]
w=list(map(int, input().split()))
max_sweetness=max(w)
sizes=[]
cnt=0
for i in range(n):
if w[i]!=max_sweetness:
cnt+= 1
else:
sizes.append(cnt)
cnt=0
if cnt!=0:
sizes[0]=(cnt+sizes[0])
res=0
for i in range(len(sizes)):
res+=max(sizes[i]-n//2+1, 0)
print(res)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Chefina has two sequences $A_1, A_2, \ldots, A_N$ and $B_1, B_2, \ldots, B_N$. She views two sequences with length $N$ as identical if, after they are sorted in non-decreasing order, the $i$-th element of one sequence is equal to the $i$-th element of the other sequence for each $i$ ($1 \le i \le N$).
To impress Chefina, Chef wants to make the sequences identical. He may perform the following operation zero or more times: choose two integers $i$ and $j$ $(1 \le i,j \le N)$ and swap $A_i$ with $B_j$. The cost of each such operation is $\mathrm{min}(A_i, B_j)$.
You have to find the minimum total cost with which Chef can make the two sequences identical.
-----Input-----
- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
- The first line of each test case contains a single integer $N$.
- The second line contains $N$ space-separated integers $A_1, A_2, \ldots, A_N$.
- The third line contains $N$ space-separated integers $B_1, B_2, \ldots, B_N$.
-----Output-----
For each test case, print a single line containing one integer ― the minimum cost, or $-1$ if no valid sequence of operations exists.
-----Constraints-----
- $1 \le T \le 2,000$
- $1 \le N \le 2 \cdot 10^5$
- $1 \le A_i, B_i \le 10^9$ for each valid $i$
- the sum of $N$ over all test cases does not exceed $2 \cdot 10^6$
-----Subtasks-----
Subtask #1 (15 points):
- $T \le 20$
- $N \le 20$
Subtask #2 (85 points): original constraints
-----Example Input-----
3
1
1
2
2
1 2
2 1
2
1 1
2 2
-----Example Output-----
-1
0
1
-----Explanation-----
Example case 1: There is no way to make the sequences identical, so the answer is $-1$.
Example case 2: The sequence are identical initially, so the answer is $0$.
Example case 3: We can swap $A_1$ with $B_2$, which makes the two sequences identical, so the answer is $1$.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
from collections import Counter
tc=int(input())
for k in range(tc):
n=int(input())
a=list(map(int, input().rstrip().split()))
b= list(map(int, input().rstrip().split()))
cc=sorted(a+b)
#print('cc = ',cc)
p=[]
q=[]
#print('len(cc) = ',len(cc))
#print('len = ',(2*n))
#rx=0
for i in range(0,(2*n),2):
p.append(cc[i])
#rx+=1
for i in range(1,(2*n)+1,2):
q.append(cc[i])
if(p!=q):
print('-1')
continue
a.sort()
b.sort()
#print(p)
#print(q)
if(a==b):
print('0')
continue
xx = list((Counter(a) - Counter(p)).elements())
yy = list((Counter(b) - Counter(p)).elements())
#print('xx = ',xx)
#print('yy = ',yy)
iu=len(xx)
gb=sorted(xx+yy)
#print(iu)
uu=xx[0]
vv=yy[0]
#print('uu = ',uu)
#print('vv = ',vv)
zz=min(cc[0],uu,vv)
#print('zz = ',zz)
ans=0
for i in range(iu):
if(gb[i]<=(zz*2)):
ans+=gb[i]
else:
ans+=(zz*2)
print(ans)
#a = [1, 1, 1, 2, 3, 3]
#b = [1, 1, 2, 2, 3, 4]
'''c = []
i, j = 0, 0
while i < len(a) and j < len(b):
if a[i] == b[j]:
c.append(a[i])
i += 1
j += 1
elif a[i] > b[j]:
j += 1
else:
i += 1'''
#print(c)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Polycarp takes part in a math show. He is given n tasks, each consists of k subtasks, numbered 1 through k. It takes him t_{j} minutes to solve the j-th subtask of any task. Thus, time required to solve a subtask depends only on its index, but not on the task itself. Polycarp can solve subtasks in any order.
By solving subtask of arbitrary problem he earns one point. Thus, the number of points for task is equal to the number of solved subtasks in it. Moreover, if Polycarp completely solves the task (solves all k of its subtasks), he recieves one extra point. Thus, total number of points he recieves for the complete solution of the task is k + 1.
Polycarp has M minutes of time. What is the maximum number of points he can earn?
-----Input-----
The first line contains three integer numbers n, k and M (1 ≤ n ≤ 45, 1 ≤ k ≤ 45, 0 ≤ M ≤ 2·10^9).
The second line contains k integer numbers, values t_{j} (1 ≤ t_{j} ≤ 1000000), where t_{j} is the time in minutes required to solve j-th subtask of any task.
-----Output-----
Print the maximum amount of points Polycarp can earn in M minutes.
-----Examples-----
Input
3 4 11
1 2 3 4
Output
6
Input
5 5 10
1 2 4 8 16
Output
7
-----Note-----
In the first example Polycarp can complete the first task and spend 1 + 2 + 3 + 4 = 10 minutes. He also has the time to solve one subtask of the second task in one minute.
In the second example Polycarp can solve the first subtask of all five tasks and spend 5·1 = 5 minutes. Also he can solve the second subtasks of two tasks and spend 2·2 = 4 minutes. Thus, he earns 5 + 2 = 7 points in total.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
n, k, m = list(map(int, input().split()))
l = list(map(int, input().split()))
l.sort()
s = sum(l)
ans = 0
for i in range(n + 1):
mi = m - s * i
if mi < 0:
break
cnt = (k + 1) * i
for j in range(k):
x = min(mi // l[j], n - i)
cnt += x
mi -= l[j] * x
ans = max(ans, cnt)
print(ans)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
You are given a set of size $m$ with integer elements between $0$ and $2^{n}-1$ inclusive. Let's build an undirected graph on these integers in the following way: connect two integers $x$ and $y$ with an edge if and only if $x \& y = 0$. Here $\&$ is the bitwise AND operation. Count the number of connected components in that graph.
-----Input-----
In the first line of input there are two integers $n$ and $m$ ($0 \le n \le 22$, $1 \le m \le 2^{n}$).
In the second line there are $m$ integers $a_1, a_2, \ldots, a_m$ ($0 \le a_{i} < 2^{n}$) — the elements of the set. All $a_{i}$ are distinct.
-----Output-----
Print the number of connected components.
-----Examples-----
Input
2 3
1 2 3
Output
2
Input
5 5
5 19 10 20 12
Output
2
-----Note-----
Graph from first sample:
$0$
Graph from second sample:
[Image]
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
n, m = map(int, input().split())
a = set(map(int, input().split()))
y = 2 ** n
mk = [0] * (2 * y)
cur = 0
for x in a:
if mk[x]: continue
mk[x] = 1
st = [x]
while st:
u = st.pop()
if u < y:
if not mk[y + u]:
mk[y + u] = 1
st.append(y + u)
else:
for b in range(n):
v = u | 1 << b
if u < v and not mk[v]:
mk[v] = 1
st.append(v)
v = y - 1 - (u - y)
if v in a and not mk[v]:
mk[v] = 1
st.append(v)
cur += 1
print(cur)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Alice lives on a line. Today, she will travel to some place in a mysterious vehicle.
Initially, the distance between Alice and her destination is D. When she input a number x to the vehicle, it will travel in the direction of the destination by a distance of x if this move would shorten the distance between the vehicle and the destination, and it will stay at its position otherwise. Note that the vehicle may go past the destination when the distance between the vehicle and the destination is less than x.
Alice made a list of N numbers. The i-th number in this list is d_i. She will insert these numbers to the vehicle one by one.
However, a mischievous witch appeared. She is thinking of rewriting one number in the list so that Alice will not reach the destination after N moves.
She has Q plans to do this, as follows:
- Rewrite only the q_i-th number in the list with some integer so that Alice will not reach the destination.
Write a program to determine whether each plan is feasible.
-----Constraints-----
- 1≤ N ≤ 5*10^5
- 1≤ Q ≤ 5*10^5
- 1≤ D ≤ 10^9
- 1≤ d_i ≤ 10^9(1≤i≤N)
- 1≤ q_i ≤ N(1≤i≤Q)
- D and each d_i are integers.
-----Input-----
Input is given from Standard Input in the following format:
N D
d_1 d_2 ... d_N
Q
q_1 q_2 ... q_Q
-----Output-----
Print Q lines. The i-th line should contain YES if the i-th plan is feasible, and NO otherwise.
-----Sample Input-----
4 10
3 4 3 3
2
4 3
-----Sample Output-----
NO
YES
For the first plan, Alice will already arrive at the destination by the first three moves, and therefore the answer is NO.
For the second plan, rewriting the third number in the list with 5 will prevent Alice from reaching the destination as shown in the following figure, and thus the answer is YES.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
n, d = list(map(int, input().split()))
D = list(map(int, input().split()))
A = [0]*(n+1)
P = [0]*(n+1)
P[0] = pos = d
for i, x in enumerate(D):
if x <= 2*pos:
pos = abs(x-pos)
P[i+1] = pos
if pos == 0:
break
for i in range(n-1, -1, -1):
if D[i] <= 2*A[i+1]+1:
A[i] = A[i+1] + D[i]
else:
A[i] = A[i+1]
q = input()
Q = list(map(int, input().split()))
for i in Q:
if P[i-1] <= A[i] and pos == 0:
print("NO")
else:
print("YES")
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Today, puppy Tuzik is going to a new dog cinema. He has already left his home and just realised that he forgot his dog-collar! This is a real problem because the city is filled with catchers looking for stray dogs.
A city where Tuzik lives in can be considered as an infinite grid, where each cell has exactly four neighbouring cells: those sharing a common side with the cell. Such a property of the city leads to the fact, that the distance between cells (xA, yA) and (xB, yB) equals |xA - xB| + |yA - yB|.
Initially, the puppy started at the cell with coordinates (0, 0). There are N dog-catchers located at the cells with the coordinates (xi, yi), where 1 ≤ i ≤ N. Tuzik's path can be described as a string S of M characters, each of which belongs to the set {'D', 'U', 'L', 'R'} (corresponding to it moving down, up, left, and right, respectively). To estimate his level of safety, Tuzik wants to know the sum of the distances from each cell on his path to all the dog-catchers. You don't need to output this sum for the staring cell of the path (i.e. the cell with the coordinates (0, 0)).
-----Input-----
The first line of the input contains two integers N and M.
The following N lines contain two integers xi and yi each, describing coordinates of the dog-catchers.
The last line of the input contains string S of M characters on the set {'D', 'U', 'L', 'R'}.
- 'D' - decrease y by 1
- 'U' - increase y by 1
- 'L' - decrease x by 1
- 'R' - increase x by 1
-----Output-----
Output M lines: for each cell of the path (except the starting cell), output the required sum of the distances.
-----Constraints-----
- 1 ≤ N ≤ 3 ✕ 105
- 1 ≤ M ≤ 3 ✕ 105
- -106 ≤ xi, yi ≤ 106
-----Example-----
Input:
2 3
1 2
0 1
RDL
Output:
4
6
6
-----Explanation-----
Initially Tuzik stays at cell (0, 0). Let's consider his path:
- Move 'R' to the cell (1, 0). Distance to the catcher (1, 2) equals 2, distance to the catcher (0, 1) equals 2, so the total distance equals 4
- Move 'D' to the cell (1, -1). Distance to the catcher (1, 2) equals 3, distance to the catcher (0, 1) equals 3, so the total distance equals 6
- Move 'L' to the cell (0, -1). Distance to the catcher (1, 2) equals 4, distance to the catcher (0, 1) equals 2, so the total distance equals 6
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
# cook your dish here
from sys import stdin,stdout
a,b=list(map(int,stdin.readline().split()))
left=[]
top=[]
for i in range(a):
c,d=list(map(int,stdin.readline().split()))
left.append(c)
top.append(d)
left.sort()
top.sort()
from bisect import bisect_right as br
from bisect import bisect_left as bl
row=0
col=0
total=0
cons_x=0
cons_y=0
for i in range(len(left)):
cons_x+=(abs(left[i]))
cons_y+=(abs(top[i]))
total=cons_x+cons_y
cc=stdin.readline().rstrip()
for i in cc:
if i=="R":
kk=br(left,col)
cons_x=(cons_x+kk-(a-kk))
col+=1
if i=="L":
kk=bl(left,col)
cons_x=(cons_x+(a-kk)-kk)
col-=1
if i=="U":
kk=br(top,row)
cons_y=(cons_y+kk-(a-kk))
row+=1
if i=="D":
kk=bl(top,row)
cons_y=(cons_y+(a-kk)-kk)
row-=1
stdout.write(str(cons_x+cons_y))
stdout.write("\n")
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
These days, chef is very much interested in Mathematics. He has started attending Recitations too! His hunger for problems is increasing day by day!
Today, chef was a given a crumpled maths problem, which he is stuck with . He needs your help to do it
Here's what his teacher said: "Find sum of all numbers till N, do not include numbers which are powers of K from K, K2, K3... which are less than or equal to N"
Easy, right? Can you solve it?
-----INPUT-----
The first line of the input contains an integer T, denoting the number of test cases. The description of T test cases follows. The first line of each test contains two integers N and K, as per the above given problem specification.
-----OUTPUT-----
For each test case, output a single line printing the sum of the each test case, in format Case #T: S, where T is the Tth test case running and S is sum of corresponding test case.
-----CONSTRAINTS-----
10 < T < 50
10 < N < 104
0 < K < 100
-----EXAMPLE-----
Input:
2
10 3
20 2
Output:
Case #1: 43
Case #2: 180
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
testCases = int(input())
for c in range(testCases):
n, k = list(map(int, input().split()))
sum = 0
i = 0
power = 1
while i <= n:
if k**power == i:
power += 1
else:
sum += i
i +=1
answer = "Case #" + str(c + 1) + ": " + str(sum)
print(answer)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
There is an infinitely long street that runs west to east, which we consider as a number line.
There are N roadworks scheduled on this street.
The i-th roadwork blocks the point at coordinate X_i from time S_i - 0.5 to time T_i - 0.5.
Q people are standing at coordinate 0. The i-th person will start the coordinate 0 at time D_i, continue to walk with speed 1 in the positive direction and stop walking when reaching a blocked point.
Find the distance each of the Q people will walk.
-----Constraints-----
- All values in input are integers.
- 1 \leq N, Q \leq 2 \times 10^5
- 0 \leq S_i < T_i \leq 10^9
- 1 \leq X_i \leq 10^9
- 0 \leq D_1 < D_2 < ... < D_Q \leq 10^9
- If i \neq j and X_i = X_j, the intervals [S_i, T_i) and [S_j, T_j) do not overlap.
-----Input-----
Input is given from Standard Input in the following format:
N Q
S_1 T_1 X_1
:
S_N T_N X_N
D_1
:
D_Q
-----Output-----
Print Q lines. The i-th line should contain the distance the i-th person will walk or -1 if that person walks forever.
-----Sample Input-----
4 6
1 3 2
7 13 10
18 20 13
3 4 2
0
1
2
3
5
8
-----Sample Output-----
2
2
10
-1
13
-1
The first person starts coordinate 0 at time 0 and stops walking at coordinate 2 when reaching a point blocked by the first roadwork at time 2.
The second person starts coordinate 0 at time 1 and reaches coordinate 2 at time 3. The first roadwork has ended, but the fourth roadwork has begun, so this person also stops walking at coordinate 2.
The fourth and sixth persons encounter no roadworks while walking, so they walk forever. The output for these cases is -1.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
from heapq import heapify, heappush, heappop
import sys
input = sys.stdin.readline
def solve():
N, Q = list(map(int, input().split()))
events = []
for i in range(N):
S, T, X = list(map(int, input().split()))
events.append((S-X-0.5, 1, X))
events.append((T-X-0.5, 0, X))
for i in range(Q):
D = int(input())
events.append((D, 2, i))
events.sort()
anss = [-1] * Q
PQ = []
isClosed = dict()
for tm, tp, x in events:
if tp == 0:
isClosed[x] = 0
elif tp == 1:
isClosed[x] = 1
heappush(PQ, x)
else:
while PQ:
if isClosed[PQ[0]] == 1:
anss[x] = PQ[0]
break
heappop(PQ)
print(('\n'.join(map(str, anss))))
solve()
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
The faculty of application management and consulting services (FAMCS) of the Berland State University (BSU) has always been popular among Berland's enrollees. This year, N students attended the entrance exams, but no more than K will enter the university. In order to decide who are these students, there are series of entrance exams. All the students with score strictly greater than at least (N-K) students' total score gets enrolled.
In total there are E entrance exams, in each of them one can score between 0 and M points, inclusively. The first E-1 exams had already been conducted, and now it's time for the last tribulation.
Sergey is the student who wants very hard to enter the university, so he had collected the information about the first E-1 from all N-1 enrollees (i.e., everyone except him). Of course, he knows his own scores as well.
In order to estimate his chances to enter the University after the last exam, Sergey went to a fortune teller. From the visit, he learnt about scores that everyone except him will get at the last exam. Now he wants to calculate the minimum score he needs to score in order to enter to the university. But now he's still very busy with minimizing the amount of change he gets in the shops, so he asks you to help him.
-----Input-----
The first line of the input contains an integer T denoting the number of test cases. The description of T test cases follows.
The first line of each test case contains four space separated integers N, K, E, M denoting the number of students, the maximal number of students who'll get enrolled, the total number of entrance exams and maximal number of points for a single exam, respectively.
The following N-1 lines will contain E integers each, where the first E-1 integers correspond to the scores of the exams conducted. The last integer corresponds to the score at the last exam, that was predicted by the fortune-teller.
The last line contains E-1 integers denoting Sergey's score for the first E-1 exams.
-----Output-----
For each test case, output a single line containing the minimum score Sergey should get in the last exam in order to be enrolled. If Sergey doesn't have a chance to be enrolled, output "Impossible" (without quotes).
-----Constraints-----
- 1 ≤ T ≤ 5
- 1 ≤ K < N ≤ 104
- 1 ≤ M ≤ 109
- 1 ≤ E ≤ 4
-----Example-----
Input:1
4 2 3 10
7 7 7
4 6 10
7 10 9
9 9
Output:4
-----Explanation-----
Example case 1. If Sergey gets 4 points at the last exam, his score will be equal to 9+9+4=22. This will be the second score among all the enrollees - the first one will get 21, the second one will get 20 and the third will have the total of 26. Thus, Sergey will enter the university.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
# cook your dish here
t=int(input())
for i in range(t):
(n,k,e,m)=tuple(map(int,input().split()))
scores=[]
for j in range(n-1):
scores.append(sum(list(map(int,input().split()))))
scores.sort(reverse=True);
bsc=scores[k-1];
msc=sum(list(map(int,input().split())))
mini=bsc-msc+1
if(mini<0):
print(0)
elif(mini>m):
print("Impossible")
else:
print(mini)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
You are playing a variation of game 2048. Initially you have a multiset $s$ of $n$ integers. Every integer in this multiset is a power of two.
You may perform any number (possibly, zero) operations with this multiset.
During each operation you choose two equal integers from $s$, remove them from $s$ and insert the number equal to their sum into $s$.
For example, if $s = \{1, 2, 1, 1, 4, 2, 2\}$ and you choose integers $2$ and $2$, then the multiset becomes $\{1, 1, 1, 4, 4, 2\}$.
You win if the number $2048$ belongs to your multiset. For example, if $s = \{1024, 512, 512, 4\}$ you can win as follows: choose $512$ and $512$, your multiset turns into $\{1024, 1024, 4\}$. Then choose $1024$ and $1024$, your multiset turns into $\{2048, 4\}$ and you win.
You have to determine if you can win this game.
You have to answer $q$ independent queries.
-----Input-----
The first line contains one integer $q$ ($1 \le q \le 100$) – the number of queries.
The first line of each query contains one integer $n$ ($1 \le n \le 100$) — the number of elements in multiset.
The second line of each query contains $n$ integers $s_1, s_2, \dots, s_n$ ($1 \le s_i \le 2^{29}$) — the description of the multiset. It is guaranteed that all elements of the multiset are powers of two.
-----Output-----
For each query print YES if it is possible to obtain the number $2048$ in your multiset, and NO otherwise.
You may print every letter in any case you want (so, for example, the strings yEs, yes, Yes and YES will all be recognized as positive answer).
-----Example-----
Input
6
4
1024 512 64 512
1
2048
3
64 512 2
2
4096 4
7
2048 2 2048 2048 2048 2048 2048
2
2048 4096
Output
YES
YES
NO
NO
YES
YES
-----Note-----
In the first query you can win as follows: choose $512$ and $512$, and $s$ turns into $\{1024, 64, 1024\}$. Then choose $1024$ and $1024$, and $s$ turns into $\{2048, 64\}$ and you win.
In the second query $s$ contains $2048$ initially.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
for i in range(int(input())):
n=int(input())
s=list(map(int,input().split()))
a=0
for i in s:
if i<2049:a+=i
if a<2048:print("NO")
else:print("YES")
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Chef is good at making pancakes. Generally he gets requests to serve N pancakes at once.
He serves them in the form of a stack.
A pancake can be treated as a circular disk with some radius.
Chef needs to take care that when he places a pancake on the top of the stack the radius of the pancake should not exceed the radius of the largest pancake in the stack by more than 1.
Additionally all radii should be positive integers, and the bottom most pancake should have its radius as 1.
Chef wants you to find out in how many ways can he create a stack containing N pancakes.
Input
First line of the input contains T (T <= 1000) denoting the number of test cases.
T lines follow each containing a single integer N (1 <= N <= 1000) denoting the size of the required stack.
Output
For each case the output should be a single integer representing the number of ways a stack of size N can be created. As the answer can be large print it modulo 1000000007.
Example
Input
2
1
2
Output
1
2
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
t=[[1]]
def bell_numbers(start, stop):
## Swap start and stop if start > stop
if stop < start: start, stop = stop, start
if start < 1: start = 1
if stop < 1: stop = 1
c = 1 ## Bell numbers count
while c <= stop:
if c >= start:
yield t[-1][0] ## Yield the Bell number of the previous row
row = [t[-1][-1]] ## Initialize a new row
for b in t[-1]:
row.append((row[-1] + b)%1000000007)
c += 1 ## We have found another Bell number
t.append(row) ## Append the row to the triangle
ar=[0]*1001
i=0
for b in bell_numbers(1,1001):
ar[i]=b
i+=1
T=eval(input())
while T:
N=eval(input())
print(ar[N])
T-=1
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Mandarin chinese
, Russian and Vietnamese as well.
Let's denote $S(x)$ by the sum of prime numbers that divides $x$.
You are given an array $a_1, a_2, \ldots, a_n$ of $n$ numbers, find the number of pairs $i, j$ such that $i \neq j$, $a_i$ divides $a_j$ and $S(a_i)$ divides $S(a_j)$.
-----Input:-----
- First line will contain $T$, number of testcases. Then the testcases follow.
- First line of each testcase contains one integer $n$ — number of elements of the array.
- Second line of each testcase contains $n$ space-separated integers $a_1, a_2, \ldots, a_n$.
-----Output:-----
For each testcase, output in a single line number of pairs that each of it satisfies given conditions.
-----Constraints-----
- $1 \leq T \leq 100$
- $2 \leq n, a_i \leq 10^6$
- the sum of $n$ for all test cases does not exceed $10^6$
-----Subtasks-----
Subtask #2 (20 points): $2 \leq n \leq 100$, $2 \leq a_i \leq 10^4$
Subtask #2 (80 points): original contsraints
-----Sample Input:-----
1
5
2 30 2 4 3
-----Sample Output:-----
6
-----EXPLANATION:-----
$S(2) = 2, S(30) = 2 + 3 + 5 = 10, S(4) = 2, S(3) = 3$. So using this information, the pairs of indicies are $(1,2)$, $(1, 3)$, $(1, 4)$, $(3, 1)$, $(3, 2)$, $(3, 4)$.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
# cook your dish here
def prime_factors(n):
i = 2
factors =set()
while i * i <= n:
if n % i:
i += 1
else:
n //= i
factors.add(i)
if n > 1:
factors.add(n)
return factors
for _ in range(int(input())):
n=int(input())
a=list(map(int,input().split()))
ans=0
s=[]
for i in range(n):
s.append(sum(prime_factors(a[i])))
for i in range(n):
for j in range(n):
if i!=j and a[j]%a[i]==0 and s[j]%s[i]==0:
ans=ans+1
print(ans)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Dreamoon likes coloring cells very much.
There is a row of $n$ cells. Initially, all cells are empty (don't contain any color). Cells are numbered from $1$ to $n$.
You are given an integer $m$ and $m$ integers $l_1, l_2, \ldots, l_m$ ($1 \le l_i \le n$)
Dreamoon will perform $m$ operations.
In $i$-th operation, Dreamoon will choose a number $p_i$ from range $[1, n-l_i+1]$ (inclusive) and will paint all cells from $p_i$ to $p_i+l_i-1$ (inclusive) in $i$-th color. Note that cells may be colored more one than once, in this case, cell will have the color from the latest operation.
Dreamoon hopes that after these $m$ operations, all colors will appear at least once and all cells will be colored. Please help Dreamoon to choose $p_i$ in each operation to satisfy all constraints.
-----Input-----
The first line contains two integers $n,m$ ($1 \leq m \leq n \leq 100\,000$).
The second line contains $m$ integers $l_1, l_2, \ldots, l_m$ ($1 \leq l_i \leq n$).
-----Output-----
If it's impossible to perform $m$ operations to satisfy all constraints, print "'-1" (without quotes).
Otherwise, print $m$ integers $p_1, p_2, \ldots, p_m$ ($1 \leq p_i \leq n - l_i + 1$), after these $m$ operations, all colors should appear at least once and all cells should be colored.
If there are several possible solutions, you can print any.
-----Examples-----
Input
5 3
3 2 2
Output
2 4 1
Input
10 1
1
Output
-1
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
def main():
import sys
input = sys.stdin.readline
N, M = list(map(int, input().split()))
L = list(map(int, input().split()))
if sum(L) < N:
print(-1)
return
ans = [0] * M
left = N
for i in range(M-1, -1, -1):
if left - L[i] >= i:
ans[i] = left - L[i] + 1
left -= L[i]
else:
if i+L[i]-1 >= N:
print(-1)
return
ans[i] = i+1
left = i
print(*ans)
def __starting_point():
main()
__starting_point()
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
IIST is thinking of acquiring some land nearby to build its new state of the art labs. The land it has chosen incidentaly has some abandoned college buildings which IIST wants to use. The administration decide the value of the building based on the amount of work that has to be done to get it in shape (lower amount of work, higher value). The security experts want to tear down some of the buildings and use the bricks to build a boundary wall.
The director has chosen you to write a program which determines the buildings which needs to be demolished to maximise the value while fulfilling the above criterion.
Input Format:
The first line contains the number of test cases, T.
The next T cases contains information about hypothetical plots.
Each test case starts with a single integer n, 2 ≤ n ≤ 15, the number of abandoned buildings in the plot. The buildings are identified by consecutive integers 1 to n. Each of the subsequent lines contains 4 integers x_i , y_i , v_i , l_i that describe a single building. (x_i, y_i) is the position of the building in the plane, v_i is its value, and l_i is the length of boundary wall that can be built using the bricks from the building. v_i and l_i are between 0 and 10,000.
Output Format:
For each test case, compute a subset of the buildings such that, using the bricks from the buildings from that subset, the remaining buildings can be enclosed in a single boundary. Find the subset with a minimum value. If more than one such minimum-value subset exists, choose one with the smallest number of buildings.
Display, as shown below, the identity of each building to be demolished, and the length of the excess boundary (accurate to two fractional digits).
Sample Input:
2
6
0 0 8 3
1 4 3 2
2 1 7 1
4 1 2 3
3 5 4 6
2 3 9 8
3
3 0 10 2
5 5 20 25
7 -3 30 32
Sample Output:
2 4 5
3.16
2
15.00
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
import math
from itertools import permutations as p
def diff(li1, li2):
li_dif = [i for i in li1 if i not in li2]
return li_dif
def segments(b):
"""A sequence of (x,y) numeric coordinates pairs """
poly = [(i[0],i[1]) for i in b]
return zip(poly, poly[1:] + [poly[0]])
def perimeter(poly):
"""A sequence of (x,y) numeric coordinates pairs """
return abs(sum(math.hypot(x0-x1,y0-y1) for ((x0, y0), (x1, y1)) in segments(poly)))
def av(b):
return sum([i[3] for i in b])
def val(b):
return sum([i[2] for i in b])
for _ in range(int(input())):
b = []
for _ in range(int(input())):
b.append(list(map(int,input().split())))
perm = []
for i in range(1,len(b)):
for e in p(b,i):
perm.append(e)
perm.sort(key=lambda x:val(x))
yes = []
for i in perm:
if av(i)>=perimeter(diff(b,i)):
good = val(i)
yes.append(i)
break
#yes.sort(key = lambda x: len(x))
print(" ".join([str(b.index(i)+1) for i in yes[0]]))
x = round(av(yes[0])-perimeter(diff(b,yes[0])),2)
print(f'{x:.2f}')
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
You are given an axis-aligned rectangle in a 2D Cartesian plane. The bottom left corner of this rectangle has coordinates (0,0)$(0, 0)$ and the top right corner has coordinates (N−1,N−1)$(N-1, N-1)$. You are also given K$K$ light sources; each light source is a point inside or on the perimeter of the rectangle.
For each light source, let's divide the plane into four quadrants by a horizontal and a vertical line passing through this light source. The light source can only illuminate one of these quadrants (including its border, i.e. the point containing the light source and two half-lines), but the quadrants illuminated by different light sources may be different.
You want to assign a quadrant to each light source in such a way that when they illuminate their respective quadrants, the entire rectangle (including its perimeter) is illuminated. Find out whether it is possible to assign quadrants to light sources in such a way.
-----Input-----
- The first line of the input contains an integer T$T$ denoting the number of test cases. The description of the test cases follows.
- The first line of each test case contains two space-separated integers K$K$ and N$N$.
- Each of the next K$K$ lines contains two space-separated integers x$x$ and y$y$ denoting a light source with coordinates (x,y)$(x, y)$.
-----Output-----
For each test case, print a single line containing the string "yes" if it is possible to illuminate the whole rectangle or "no" if it is impossible.
-----Constraints-----
- 1≤T≤5,000$1 \le T \le 5,000$
- 1≤K≤100$1 \le K \le 100$
- 1≤N≤109$1 \le N \le 10^9$
- 0≤x,y≤N−1$0 \le x, y \le N-1$
- no two light sources coincide
-----Example Input-----
2
2 10
0 0
1 0
2 10
1 2
1 1
-----Example Output-----
yes
no
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
# https://www.codechef.com/problems/RECTLIT
def assess(sq,points):
EWct = 0
NSct = 0
for a,b in points:
EW = (a == 0 or a == sq)
NS = (b == 0 or b == sq)
if EW and NS:
return 'yes'
EWct += EW
NSct += NS
if NSct + EWct == 0 or len(points) == 1:
return 'no'
if EWct >= 2 or NSct >= 2:
return 'yes'
if len(points) == 2:
return 'no'
# now 3 points
if NSct == 1 and EWct == 1:
return 'yes'
# 3 points, one on edge
x = -1
for a,b in points:
if EWct > 0:
if a == 0 or a == sq:
e = b
elif x == -1:
x = b
else:
y = b
else:
if b == 0 or b == sq:
e = a
elif x == -1:
x = a
else:
y = a
if (e-x)*(e-y) < 0: # edge splits mids
return 'no'
else:
return 'yes'
for ti in range(int(input())):
k,n = map(int, input().split())
if k > 3:
for ki in range(k):
input()
print('yes')
else:
pos = [tuple(map(int, input().split())) for ki in range(k)]
print(assess(n-1,pos))
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
There is a building with $N$ floors (numbered $1$ through $N$ from bottom to top); on each floor, there are $M$ windows (numbered $1$ through $M$ from left to right). Let's denote the $j$-th window on the $i$-th floor by $(i, j)$.
All windows in the building need to be cleaned one by one in a specific order. You are given this order as a matrix $A$ with $N$ rows and $M$ columns; for each valid $i$ and $j$, the window $(i, j)$ must be cleaned on the $A_{N-i+1,j}$-th turn.
Whenever we clean a window $(i, j)$, it becomes clean, but the dirty water used for cleaning it flows down to windows $(i-1, j-1)$, $(i-1, j)$ and $(i-1, j+1)$ (more precisely, to all of these windows which exist), so these windows become dirty again. Then, the water flows further down, so the same applies for other windows below: whenever a window $(i, j)$ becomes dirty, windows $(i-1, j-1)$, $(i-1, j)$ and $(i-1, j+1)$ become dirty as well. For example, cleaning a window $(5, 3)$ will make the window $(3, 2)$ dirty. The next window is cleaned only after water flows down completely. Note that each window is cleaned only once and there may be dirty windows at the end.
For each window, determine whether it will be clean after the cleaning process ends.
-----Input-----
- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
- The first line of each test case contains two space-separated integers $N$ and $M$.
- $N$ lines follow. For each $i$ ($1 \le i \le N$), the $i$-th of these lines contains $M$ space-separated integers $A_{i, 1}, A_{i, 2}, \ldots, A_{i, M}$.
-----Output-----
For each test case, print $N$ lines; each of them should contain a string with length $M$. For each valid $i$ and $j$, the $j$-th character on the $i$-th line should be '1' if the window $(N-i+1, j)$ is clean or '0' if it is dirty.
-----Constraints-----
- $1 \le T \le 1,000$
- $1 \le N, M \le 10^3$
- $1 \le A_{i, j} \le N \cdot M$ for each valid $i, j$
- the elements of the matrix $A$ are pairwise distinct
- the sum of $N \cdot M$ over all test cases does not exceed $10^6$
-----Subtasks-----
Subtask #1 (50 points):
- $N, M \le 25$
- the sum of $N \cdot M$ over all test cases does not exceed $625$
Subtask #2 (50 points): original constraints
-----Example Input-----
1
3 4
1 3 7 10
9 2 4 11
8 12 5 6
-----Example Output-----
1111
1001
0100
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
try:
t = int(input())
while(t > 0):
t -= 1
n,m = list(map(int,input().split()))
a = [list(map(int,input().split())) for _ in range(n)]
dp = [[0 for _ in range(m)] for _ in range(n)]
ans = [['0' for _ in range(m)] for _ in range(n)]
for i in range(n):
for j in range(m):
if i-1 < n:
if 0 <= j-1 and j+1 < m:
dp[i][j] = max(dp[i-1][j-1],dp[i-1][j],dp[i-1][j+1])
elif j == 0:
dp[i][j] = max(dp[i-1][j],dp[i-1][j+1])
elif j == m-1:
dp[i][j] = max(dp[i-1][j-1],dp[i-1][j])
if dp[i][j] > a[i][j]:
ans[i][j] = '0'
else:
ans[i][j] = '1'
dp[i][j] = a[i][j]
for i in ans:
print(''.join(i))
except:
pass
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
A permutation of length n is an array of size n consisting of n distinct integers in the range [1, n]. For example, (3, 2, 4, 1) is a permutation of length 4, but (3, 3, 1, 4) and (2, 3, 4, 5) are not, as (3, 3, 1, 4) contains duplicate elements, and (2, 3, 4, 5) contains elements not in range [1,4].
A permutation p of length n is good if and only if for any 1 ≤ i ≤ n, pi ≠ i.
Please find the lexicographically smallest good permutation p.
Definition for "lexicographically smaller":
For two permutations p and q, we say that p is lexicographically smaller than q if and only if there exists a index 1 ≤ l ≤ n such that:
- For any 1 ≤ i < l, pi = qi. Note that if l = 1, this constraint means nothing.
- and, pl < ql.
For example, (2, 3, 1, 4) < (2, 3, 4, 1) < (3, 4, 1, 2). The lexicographically smallest permutation is, of course, (1, 2, ..., n), though this one is not good.
-----Input-----
First line of the input contains an integer T denoting number of test cases.
For each test case, the only line contains an integer n.
-----Output-----
For each test case, output the lexicographically smallest good permutation of length n. It's guaranteed that this permutation exists.
-----Constraints-----
- 1 ≤ T ≤ 10
- 2 ≤ n ≤ 105
-----Subtasks-----
- Subtask #1 (17 points): 2 ≤ n ≤ 9
- Subtask #2 (83 points): Original Constraints
-----Example-----
Input:
4
2
3
5
6
Output:
2 1
2 3 1
2 1 4 5 3
2 1 4 3 6 5
-----Explanation-----
Example case 1. The only good permutation of length 2 is (2, 1).
Example case 2. Consider all permutations of length 3, they are(in lexicographically order):
- p = (1, 2, 3), it's not good since p[1] = 1, p[2] = 2 and p[3] = 3;
- p = (1, 3, 2), it's not good since p[1] = 1;
- p = (2, 1, 3), it's not good since p[3] = 3;
- p = (2, 3, 1), it's good since p[1] ≠ 1, p[2] ≠ 2 and p[3] ≠ 3;
- p = (3, 1, 2), it's good since p[1] ≠ 1, p[2] ≠ 2 and p[3] ≠ 3;
- p = (3, 2, 1), it's not good since p[2] = 2.
Thus the minimum good one is (2, 3, 1).
Example case 3. Consider two good permutations for third test case: p=(2, 1, 4, 5, 3) and q=(2, 4, 1, 5, 3), then p < q. You can check lexicographically condition as follows. Find the first index where the entries of two permutations are different, and compare those entries. For example, in this case, the first position where the entries differ is index 2. You can see that p[2] < q[2], as 1 < 4, so p is lexicographically smaller than q.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
tests = int(input())
for t in range(tests):
n = int(input())
permut='2'
permut_list=[]
if n%2==0:
for i in range(2, n+1):
if i%2==1:
permut=permut+' '+str(i+1)
else:
permut=permut+' '+str(i-1)
print(permut)
pass
elif n==1:
print(1)
pass
else:
for i in range(2, n):
if i%2==1:
permut_list.append(str(i+1))
else:
permut_list.append(str(i-1))
permut_list.pop(-1)
permut_list.append(str(n))
permut_list.append(str(n-2))
this_permut='2'
for el in permut_list:
this_permut=this_permut+' '+el
print(this_permut)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Mike is the president of country What-The-Fatherland. There are n bears living in this country besides Mike. All of them are standing in a line and they are numbered from 1 to n from left to right. i-th bear is exactly a_{i} feet high.
[Image]
A group of bears is a non-empty contiguous segment of the line. The size of a group is the number of bears in that group. The strength of a group is the minimum height of the bear in that group.
Mike is a curious to know for each x such that 1 ≤ x ≤ n the maximum strength among all groups of size x.
-----Input-----
The first line of input contains integer n (1 ≤ n ≤ 2 × 10^5), the number of bears.
The second line contains n integers separated by space, a_1, a_2, ..., a_{n} (1 ≤ a_{i} ≤ 10^9), heights of bears.
-----Output-----
Print n integers in one line. For each x from 1 to n, print the maximum strength among all groups of size x.
-----Examples-----
Input
10
1 2 3 4 5 4 3 2 1 6
Output
6 4 4 3 3 2 2 1 1 1
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
def read_data():
n = int(input())
hs = list(map(int, input().split()))
return n, hs
def solve(n, hs):
left = get_left_index(n, hs)
right = get_right_index(n, hs)
vals = [[] for i in range(n)]
for h, l, r in zip(hs, left, right):
vals[r - l - 2].append(h)
min_hs = []
min_h = - float('inf')
for val in vals[::-1]:
for v in val:
min_h = max(min_h, v)
min_hs.append(min_h)
print(* min_hs[::-1])
def get_left_index(n, hs):
left = []
stack = []
for i, h in enumerate(hs):
while stack and hs[stack[-1]] >= h:
del stack[-1]
if stack:
left.append(stack[-1])
else:
left.append(-1)
stack.append(i)
return left
def get_right_index(n, hs):
hs.reverse()
tmp = get_left_index(n, hs)
hs.reverse()
tmp.reverse()
right = [n - 1 - a for a in tmp]
return right
n, hs = read_data()
solve(n, hs)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Anton likes to listen to fairy tales, especially when Danik, Anton's best friend, tells them. Right now Danik tells Anton a fairy tale:
"Once upon a time, there lived an emperor. He was very rich and had much grain. One day he ordered to build a huge barn to put there all his grain. Best builders were building that barn for three days and three nights. But they overlooked and there remained a little hole in the barn, from which every day sparrows came through. Here flew a sparrow, took a grain and flew away..."
More formally, the following takes place in the fairy tale. At the beginning of the first day the barn with the capacity of n grains was full. Then, every day (starting with the first day) the following happens: m grains are brought to the barn. If m grains doesn't fit to the barn, the barn becomes full and the grains that doesn't fit are brought back (in this problem we can assume that the grains that doesn't fit to the barn are not taken into account). Sparrows come and eat grain. In the i-th day i sparrows come, that is on the first day one sparrow come, on the second day two sparrows come and so on. Every sparrow eats one grain. If the barn is empty, a sparrow eats nothing.
Anton is tired of listening how Danik describes every sparrow that eats grain from the barn. Anton doesn't know when the fairy tale ends, so he asked you to determine, by the end of which day the barn will become empty for the first time. Help Anton and write a program that will determine the number of that day!
-----Input-----
The only line of the input contains two integers n and m (1 ≤ n, m ≤ 10^18) — the capacity of the barn and the number of grains that are brought every day.
-----Output-----
Output one integer — the number of the day when the barn will become empty for the first time. Days are numbered starting with one.
-----Examples-----
Input
5 2
Output
4
Input
8 1
Output
5
-----Note-----
In the first sample the capacity of the barn is five grains and two grains are brought every day. The following happens: At the beginning of the first day grain is brought to the barn. It's full, so nothing happens. At the end of the first day one sparrow comes and eats one grain, so 5 - 1 = 4 grains remain. At the beginning of the second day two grains are brought. The barn becomes full and one grain doesn't fit to it. At the end of the second day two sparrows come. 5 - 2 = 3 grains remain. At the beginning of the third day two grains are brought. The barn becomes full again. At the end of the third day three sparrows come and eat grain. 5 - 3 = 2 grains remain. At the beginning of the fourth day grain is brought again. 2 + 2 = 4 grains remain. At the end of the fourth day four sparrows come and eat grain. 4 - 4 = 0 grains remain. The barn is empty.
So the answer is 4, because by the end of the fourth day the barn becomes empty.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
n, m = map(int, input().split())
if (m >= n): print(n)
else:
c = n - m
l = 0
r = 10 ** 18
while r - l > 1:
md = (r + l) // 2
if (1 + md) * md // 2 < c:
l = md
else:
r = md
print(r + m)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
You are given a rooted tree on N vertices. The nodes are numbered from 1 to N, and Node 1 is the root. Each node u has an associated value attached to it: Au.
For each vertex v, we consider the path going upwards from v to the root. Suppose that path is v1, v2, .., vk, where v1 = v and vk = 1. The cost of any node on this path is equal to the minimum value among all the nodes to its left in the path sequence, including itself. That is, cost(vi) = min1 <= j <= i{Avj}. And the cost of the path is the sum of costs of all the nodes in it.
For every node in the tree, find the cost of the path from that node to the root.
-----Input-----
- The first line of the input contains a single integer, N, denoting the number of nodes in the tree.
- The next line contains N-1 integers, the i-th of which denotes the parent of node i+1.
- The next line contains N integers, the i-th of which denotes Ai.
-----Output-----
Output a single line containing N integers, the i-th of which should be the cost of the path from node i to the root.
-----Constraints-----
- 1 ≤ N ≤ 100,000
- -1,000,000,000 ≤ Av ≤ 1,000,000,000
-----Subtasks-----
- Subtask #1 (30 points): 1 ≤ N ≤ 2000
- Subtask #2 (70 points): Original constraints.
-----Example-----
Input:
8
1 1 1 1 5 8 6
1 2 3 4 5 15 70 10
Output:
1 3 4 5 6 21 96 26
-----Explanation-----
For example, take a look at the path from vertex 7: The path is 7 -> 8 -> 6 -> 5 -> 1.
Cost(7) has no choice but to be A7. So Cost(7) = 70.
Cost(8) will be minimum of A7 and A8, which turns out to be A8. So Cost(8) = 10.
Cost(6) = minimum {A7, A8, A6} = minimum {70, 10, 15} = 10.
Cost(5) = minimum {70, 10, 15, 5} = 5.
Cost(1) = minimum {70, 10, 15, 5, 1} = 1.
So, the cost of the path from 7 to the root is 70 + 10 + 10 + 5 + 1 = 96.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
import sys
n = eval(input())
parents = [int(x)-1 for x in input().split(' ')]
values = list(map(int , input().split(' ')))
parents = [0]+parents
# print(parents)
# print(values)
def single_node_cost(i):
cost = 0
# print('started with ',i)
min_value = sys.maxsize
while i != 0:
min_value = min(min_value,values[i])
cost += min_value
# print(i,min_value)
i = parents[i]
cost += min(values[0],min_value)
return cost
for i in range(n):
print(single_node_cost(i), end=' ')
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
You are given a string S containing only lowercase characters.
You can rearrange the string and you have to print minimum number of characters needed(can be 0) to make it palindrome.
-----Input:-----
- First line contain an interger T denoting number of testcases.
- First line of each testcase contains integer N, size of string.
- Second line of each testcase contains string S.
-----Output:-----
For each test case, print a single line containing one integer ― the minimum number of characters needed(can be 0) to make it palindrome.
-----Constraints-----
- $1 \leq T \leq 1000$
- $1 \leq N \leq 10^5$
-----Sample Input:-----
3
1
a
9
abbbcbddd
6
abcdef
-----Sample Output:-----
0
2
5
-----EXPLANATION:-----
- Example case 1: a is already a palindrome.
- Example case 2: abbddcddbba is palindrome by adding 2 more characters.
- Example case 3: abdefcfedba is palindrome by adding 5 more characters.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
# cooking dish here
from sys import stdin
from collections import Counter
read = stdin.readline
for testcase in range(int(read())):
length = int(read())
string = read().strip()
counts = Counter(string)
odd_counts = 0
for count in list(counts.values()):
# print(count, counts)
odd_counts += count%2
print(max(odd_counts-1, 0))
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Indian National Olympiad in Informatics 2013
Calvin wakes up early one morning and finds that all his friends in the hostel are asleep. To amuse himself, he decides to play the following game : he draws a sequence of N squares on the ground, numbered 1 to N, and writes an integer in each square. He starts at square k (1 ≤ k ≤ N). The game consists of one forward phase followed by one backward phase.
- In the forward phase, Calvin makes zero or more moves of the following type : if his current position is p, he can jump to p+1 or p+2 as long as he stays within the N squares.
- In the backward phase, Calvin makes zero or more moves of the following type : if his current position is p, he can jump to p−1 or p−2 as long as he stays within the N squares.
He plays such that he finally ends up at square 1, and then he stops. He starts with a score of 0, and each time he jumps from square i to square j, he adds the integer written in square j to his score. Find the maximum score Calvin can obtain by playing this game. Recall that Calvin must start at square k and end at square 1. The integer on the square where he starts is not included in his score.
For example, suppose N = 5 and the numbers in squares are 5, 3, −2, 1, 1. If k = 2, Calvin starts on the second square. He can make a forward move to square 4, another to square 5, a backward move to square 4, another to square 2, and another to square 1. His total score is 1+1+1+3+5 = 11. You can check that this is the maximum score possible.
-----Input format-----
• Line 1 : Two space-separated integers, N and k, with 1 ≤ k ≤ N.
• Line 2 : A space-separated sequence of N integers, the numbers in squares 1, 2 . . . , N .
-----Output format-----
A single line with a single integer, the maximum score Calvin can obtain by playing the game.
-----Test Data-----
The testdata is grouped into two subtasks with the following constraints on the inputs.
• Subtask 1 [30 points] : 1 ≤ N ≤ 3000.
• Subtask 2 [70 points] : 1 ≤ N ≤ 106.
In all subtasks, the number in each square is between −1000 and 1000 inclusive.
-----Example-----
Here is the sample input and output corresponding to the example above.
-----Sample input-----
5 2
5 3 -2 1 1
-----Sample output-----
11
Note: Your program should not print anything other than what is specified in the output format. Please remove all diagnostic print statements before making your final submission. A program with extraneous output will be treated as incorrect!
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
try:
n, k=map(int, input().split())
arr=list(map(int, input().split()))
forward = [0]*(n+1)
backward= [0]*(n+1)
backward[0]=arr[0]
backward[1]=arr[0]+arr[1]
for i in range(k, n):
forward[i]=arr[i] +max(forward[i-1],forward[i-2])
for i in range(2, n):
backward[i]=arr[i]+max(backward[i-1],backward[i-2])
ans=-float("Inf")
for i in range(k-1, n):
ans=max(ans, forward[i]+backward[i]-arr[i])
print(ans)
except Exception:
pass
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
The chef likes to play with numbers. He takes some integer number x, writes it down on his iPad, and then performs with it n−1 operations of the two kinds:
- divide the number x by 3 (x must be divisible by 3);
- multiply the number x by 2.
After each iteration, Chef writes down the result on his iPad and replaces x with the result. So there will be n numbers on the iPad after all.
You are given a sequence of length n — the numbers that Chef wrote down. This sequence is given in the order of the sequence can mismatch the order of the numbers written on the iPad.
Your problem is to rearrange elements of this sequence in such a way that it can match a possible Chef's game in the order of the numbers written on the board. I.e. each next number will be exactly two times the previous number or exactly one-third of the previous number.
I can give a guarantee that the answer exists.
-----Input:-----
- The first line of the input contains an integer number N i.e the number of the elements in the sequence.
- The second line of the input contains n integer numbers a1,a2,…, an i.e rearranged (reordered) sequence that Chef can write down on the iPad.
-----Output:-----
Print N integer numbers — rearranged (reordered) input sequence that can be the sequence that Chef could write down on the iPad.
It is guaranteed that the answer exists
-----Constraints-----
- $2 \leq N \leq 100$
- $1 \leq A[i] \leq 3* 10^{18} $
-----Sample Input:-----
6
4 8 6 3 12 9
-----Sample Output:-----
9 3 6 12 4 8
-----EXPLANATION:-----
In the first example, the given sequence can be rearranged in the following way: [9,3,6,12,4,8]. It can match possible Polycarp's game which started with x=9.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
class Node:
def __init__(self,x):
self.x=x
self.next=None
self.prev=None
self.flag=True
for t in range(1):
n=int(input())
arr=list(map(int,input().split()))
for i in range(n):
arr[i]=Node(arr[i])
for i in arr:
d=[i.x%3==0,i.x,i.x//3,i.x*2]
if d[0]:
for j in arr:
if j.x==d[2]:
i.next=j
j.prev=i
break
else:
for j in arr:
if j.x == d[3]:
i.next = j
j.prev = i
break
else:
for j in arr:
if j.x==d[3]:
i.next=j
j.prev=i
break
f,l=None,None
for i in arr:
if i.prev==None:
f=i
elif i.next==None:
l=i
while f!=l and l!=None:
print(f.x,end=" ")
f=f.next
print(f.x)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Back in 2015, Usain Bolt announced that he'll be retiring after the 2017 World Championship. Though his final season did not end gloriously, we all know that he is a true legend and we witnessed his peak during 2008 - 2013.
Post retirement, Usain Bolt is still leading an adventurous life. He's exploring the unexplored parts of the globe. But sometimes he gets bored, and reads questions asked about him on Quora. One such question he read was, "Who would win a race between Usain Bolt and a tiger if the race is on a straight line track and the tiger is $distancetoBolt$ meters behind Bolt? The finishing point is $finish$ meters away from Bolt's starting position. The tiger starts with an initial speed of $0$ $meter/second$, and will accelerate itself with $tigerAccelaration$ $m/s^2$. Bolt can run with a constant speed of $boltSpeed$ $m/s$ from start to finish. Given these values, find out who will win the race - Bolt or the tiger? "
Note that Bolt will win the race if and only if he touches the finishing line before the tiger touches it. If both of them finish together, the tiger is announced as the winner since Bolt was given an initial advantage. See the figure below for more clarity.
Since Bolt was busy practicing in the tracks during his Physics school classes, he is asking for your help to solve the question. Can you please help him?
He just remembers two formulae from the class, and thinks that they will be useful to you:
$Displacement (S) $ = $ut$ +$ (1/2)at^2$ where $u$ is the initial velocity , #$ $is the acceleration and $t$ is the time taken.
$Velocity$ = $Displacement /Time$
-----Input:-----
- The first line will contain $T$, the number of testcases. Then the description of each test case follow.
- Each test case contains 4 integers $finish, distancetoBolt, tigerAccelaration, boltSpeed$.
-----Output:-----
For each testcase, output in a single line, the word "Bolt" or "Tiger" without quotes, depending on whether Bolt wins or the tiger wins.
-----Constraints-----
- $1 \leq T \leq 100000$
- $1 \leq finish\leq 10^5$
- $1 \leq distancetoBolt\leq 10^5$
- $1 \leq tigerAccelaration\leq 10^5$
- $1 \leq boltSpeed\leq 10^5$
-----Sample Input:-----
2
10 100 10 10
100 10 5 10
-----Sample Output:-----
Bolt
Tiger
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
for i in range(int(input())):
finish,distanetobolt,tigerAcceleration,boltspeed=map(int,input().split())
t1=((2*(finish+distanetobolt)/(tigerAcceleration))**0.5)
t2=(finish/boltspeed)
if t1>t2:
print("Bolt")
elif t1<t2:
print("Tiger")
else:
print("Tiger")
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
We have a tree with N vertices. The vertices are numbered 1, 2, ..., N. The i-th (1 ≦ i ≦ N - 1) edge connects the two vertices A_i and B_i.
Takahashi wrote integers into K of the vertices. Specifically, for each 1 ≦ j ≦ K, he wrote the integer P_j into vertex V_j. The remaining vertices are left empty. After that, he got tired and fell asleep.
Then, Aoki appeared. He is trying to surprise Takahashi by writing integers into all empty vertices so that the following condition is satisfied:
- Condition: For any two vertices directly connected by an edge, the integers written into these vertices differ by exactly 1.
Determine if it is possible to write integers into all empty vertices so that the condition is satisfied. If the answer is positive, find one specific way to satisfy the condition.
-----Constraints-----
- 1 ≦ N ≦ 10^5
- 1 ≦ K ≦ N
- 1 ≦ A_i, B_i ≦ N (1 ≦ i ≦ N - 1)
- 1 ≦ V_j ≦ N (1 ≦ j ≦ K) (21:18, a mistake in this constraint was corrected)
- 0 ≦ P_j ≦ 10^5 (1 ≦ j ≦ K)
- The given graph is a tree.
- All v_j are distinct.
-----Input-----
The input is given from Standard Input in the following format:
N
A_1 B_1
A_2 B_2
:
A_{N-1} B_{N-1}
K
V_1 P_1
V_2 P_2
:
V_K P_K
-----Output-----
If it is possible to write integers into all empty vertices so that the condition is satisfied, print Yes. Otherwise, print No.
If it is possible to satisfy the condition, print N lines in addition. The v-th (1 ≦ v ≦ N) of these N lines should contain the integer that should be written into vertex v. If there are multiple ways to satisfy the condition, any of those is accepted.
-----Sample Input-----
5
1 2
3 1
4 3
3 5
2
2 6
5 7
-----Sample Output-----
Yes
5
6
6
5
7
The figure below shows the tree when Takahashi fell asleep. For each vertex, the integer written beside it represents the index of the vertex, and the integer written into the vertex is the integer written by Takahashi.
Aoki can, for example, satisfy the condition by writing integers into the remaining vertices as follows:
This corresponds to Sample Output 1. Note that other outputs that satisfy the condition will also be accepted, such as:
Yes
7
6
8
7
7
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
import sys
input = lambda: sys.stdin.readline().rstrip()
from collections import deque
N = int(input())
X = [[] for i in range(N)]
for i in range(N-1):
x, y = map(int, input().split())
X[x-1].append(y-1)
X[y-1].append(x-1)
Y = [(-10**9, 10**9) for _ in range(N)]
K = int(input())
for _ in range(K):
v, p = map(int, input().split())
Y[v-1] = (p, p)
P = [-1] * N
Q = deque([0])
R = []
while Q:
i = deque.popleft(Q)
R.append(i)
for a in X[i]:
if a != P[i]:
P[a] = i
X[a].remove(i)
deque.append(Q, a)
def calc():
for i in R[::-1]:
e, o = 0, 0
l, r = Y[i]
if r != 10 ** 9:
if l % 2:
o = 1
else:
e = 1
for j in X[i]:
a, b = Y[j]
if b == 10**9: continue
if a % 2:
e = 1
else:
o = 1
l = max(l, a - 1)
r = min(r, b + 1)
if (e and o) or (l > r):
print("No")
return 0
elif e or o:
Y[i] = (l, r)
for i in R[1:]:
if Y[P[i]][0] - 1 >= Y[i][0]:
Y[i] = (Y[P[i]][0] - 1, 0)
else:
Y[i] = (Y[P[i]][0] + 1, 0)
print("Yes")
for i in range(N):
print(Y[i][0])
calc()
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Do you know Professor Saeed? He is the algorithms professor at Damascus University. Yesterday, he gave his students hard homework (he is known for being so evil) - for a given binary string $S$, they should compute the sum of $F(S, L, R)$ over all pairs of integers $(L, R)$ ($1 \le L \le R \le |S|$), where the function $F(S, L, R)$ is defined as follows:
- Create a string $U$: first, set $U = S$, and for each $i$ ($L \le i \le R$), flip the $i$-th character of $U$ (change '1' to '0' or '0' to '1').
- Then, $F(S, L, R)$ is the number of valid pairs $(i, i + 1)$ such that $U_i = U_{i+1}$.
As usual, Professor Saeed will give more points to efficient solutions. Please help the students solve this homework.
-----Input-----
- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
- The first and only line of each test case contains a single string $S$.
-----Output-----
For each test case, print a single line containing one integer $\sum_{1 \le L \le R \le |S|} F(S, L, R)$.
-----Constraints-----
- $1 \le T \le 100$
- $1 \le |S| \le 3 \cdot 10^6$
- the sum of $|S|$ over all test cases does not exceed $6 \cdot 10^6$
-----Subtasks-----
Subtask #1 (50 points):
- $1 \le |S| \le 300$
- the sum of $|S|$ over all test cases does not exceed $600$
Subtask #2 (50 points): original constraints
-----Example Input-----
1
001
-----Example Output-----
6
-----Explanation-----
Example case 1:
- $L = 1, R = 1$: $U$ is "101", $F = 0$
- $L = 2, R = 2$: $U$ is "011", $F = 1$
- $L = 3, R = 3$: $U$ is "000", $F = 2$
- $L = 1, R = 2$: $U$ is "111", $F = 2$
- $L = 2, R = 3$: $U$ is "010", $F = 0$
- $L = 1, R = 3$: $U$ is "110", $F = 1$
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
for _ in range(int(input())):
s=input()
n=len(s)
t=0
ans=0
for i in range(n-1):
if(s[i]==s[i+1]):
t=t+1
x=t
for i in range(n):
t=x
if(i!=0):
if(s[i]==s[i-1]):
t=t-1
else:
t=t+1
y=t
for j in range(i,n):
t=y
try:
if(s[j]==s[j+1]):
t=t-1
else:
t=t+1
except:
pass
ans=ans+t
print(ans)
``` |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.