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:
Abhishek is fond of playing cricket very much. One morning, he is playing cricket with his friends. Abhishek is a right-hand batsman
.He has to face all types of balls either good or bad. There are total 26 balls in the game and each ball is represented
by one of the following two ways:-
1. "g" denotes a good ball.
2. "b" denotes a bad ball.
All 26 balls are represented by lower case letters (a,b,.....z).
Balls faced by Abhishek are represented as a string s, all the characters of which are lower case i.e, within 26 above mentioned balls.
A substring s[l...r] (1≤l≤r≤|s|) of string s=s1s2...s|s| (where |s| is the length of string s) is string slsl+1...sr.
The substring s[l...r] is good, if among the letters slsl+1...sr, there are at most k bad ones (refer sample explanation ).
Your task is to find out the number of distinct good substrings for the given string s. Two substrings s[x...y] and s[p...q] are considered distinct if their contents are different, i.e. s[x...y]≠s[p...q].
-----Input Format-----
First Line contains an integer T, number of test cases. For each test case, first line contains a string - a sequence of balls faced by Abhishek.
And, next line contains a string of characters "g" and "b" of length 26 characters. If the ith character of this string equals "1", then the i-th English letter is good, otherwise it's bad. That is, the first character of this string corresponds to letter "a", the second one corresponds to letter "b" and so on.
And, the third line of the test case consists of a single integer k (0≤k≤|s|) — the maximum acceptable number of bad characters in a good substring.
-----Output Format -----
For each test case, print a single integer — the number of distinct good substrings of string s.
-----Constraints-----
- 1<=T<=1000
- 1<=|s|<=2000
- 0<=k<=|s|
-----Subtasks-----
Subtask 1 : 20 Points
- 1<=T<=10
- 1<=|s|<=20
- 0<=k<=|s|
Subtask 2 : 80 Points
Original Constraints
Sample Input
2
ababab
bgbbbbbbbbbbbbbbbbbbbbbbbb
1
acbacbacaa
bbbbbbbbbbbbbbbbbbbbbbbbbb
2
Sample Output
5
8
Explanation
In the first test case there are following good substrings: "a", "ab", "b", "ba", "bab".
In the second test case there are following good substrings: "a", "aa", "ac", "b", "ba", "c", "ca", "cb".
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
import sys
for _ in range(0,eval(input())):
d,inp,mp,n,q=set(),list(map(ord,list(sys.stdin.readline().strip()))),[x=='b' for x in list(sys.stdin.readline().strip())],eval(input()),ord('a')
inps = [inp[i:] for i in range(len(inp))]
inps.sort()
op,prev= 0,''
for ip in inps:
i,ct=0,0
while i < min(len(ip),len(prev)):
if prev[i] != ip[i]:
break
if mp[ip[i]-q]:
ct = ct+ 1
i = i+1
while i < len(ip):
if mp[ip[i]-q]:
ct = ct + 1
if ct > n:
break
op,i= op+1,i+1
prev = ip
print(op)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
In Chefland, there is a monthly robots competition. In the competition, a grid table of N rows and M columns will be used to place robots. A cell at row i and column j in the table is called cell (i, j). To join this competition, each player will bring two robots to compete and each robot will be placed at a cell in the grid table. Both robots will move at the same time from one cell to another until they meet at the same cell in the table. Of course they can not move outside the table. Each robot has a movable range. If a robot has movable range K, then in a single move, it can move from cell (x, y) to cell (i, j) provided (|i-x| + |j-y| <= K). However, there are some cells in the table that the robots can not stand at, and because of that, they can not move to these cells. The two robots with the minimum number of moves to be at the same cell will win the competition.
Chef plans to join the competition and has two robots with the movable range K1 and K2, respectively. Chef does not know which cells in the table will be used to placed his 2 robots, but he knows that there are 2 cells (1, 1) and (1, M) that robots always can stand at. Therefore, he assumes that the first robot is at cell (1, 1) and the other is at cell (1, M). Chef wants you to help him to find the minimum number of moves that his two robots needed to be at the same cell and promises to give you a gift if he wins the competition.
-----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 4 space-separated integers N M K1 K2 denoting the number of rows and columns in the table and the movable ranges of the first and second robot of Chef.
- The next N lines, each line contains M space-separated numbers either 0 or 1 denoting whether the robots can move to this cell or not (0 means robots can move to this cell, 1 otherwise). It makes sure that values in cell (1, 1) and cell (1, M) are 0.
-----Output-----
For each test case, output a single line containing the minimum number of moves that Chef’s 2 robots needed to be at the same cell. If they can not be at the same cell, print -1.
-----Constraints-----
- 1 ≤ T ≤ 10
- 1 ≤ N, M ≤ 100
- 0 ≤ K1, K2 ≤ 10
----- Subtasks -----
Subtask #1 : (25 points)
- K1 = K2 = 1
Subtask # 2 : (75 points)
Original Constraints
-----Example-----
Input:
2
4 4 1 1
0 1 1 0
0 1 1 0
0 1 1 0
0 0 0 0
4 4 1 1
0 1 1 0
0 1 1 0
0 1 1 0
1 0 0 1
Output:
5
-1
-----Explanation-----
Example case 1. Robot 1 can move (1, 1) -> (2, 1) -> (3, 1) -> (4, 1) -> (4, 2) -> (4, 3), and robot 2 can move (1, 4) -> (2, 4) -> (3, 4) -> (4, 4) -> (4, 3) -> (4, 3), they meet at cell (4, 3) after 5 moves.
Example case 2. Because the movable range of both robots is 1, robot 1 can not move from (3, 1) to (4, 2), and robot 2 can not move from (3, 4) to (4, 3. Hence, they can not meet each other.
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 spaces(a,n,m,k,visit1,visit2,dist,position):
queue = [position]
lastedit = []
dist[position[0]][position[1]] = 0
while queue!=[]:
point = queue[0]
i = point[0]
j = point[1]
#print 'point',i,j
if visit1[i][j]==False:
visit1[i][j] = True
startx = max(i-k,0)
endx = min(i+k,n-1)
for x in range(startx,endx+1):
starty = max(0,j+abs(x-i)-k)
endy = min(m-1,j-abs(x-i)+k)
for y in range(starty,endy+1):
if (a[x][y]==0 and visit1[x][y]==False):
if visit2[x][y]==True:
lastedit.append([x,y])
#print x,y,
if dist[x][y]>dist[i][j]+1:
dist[x][y]=dist[i][j]+1
queue.append([x,y])
#print queue,dist
queue = queue[1:]
#print
return lastedit
for t in range(int(input())):
n,m,k1,k2 = list(map(int,input().split()))
a = []
for i in range(n):
a.append(list(map(int,input().split())))
#print a
value = sys.maxsize
listing = []
visit1 = [[False for i in range(m)]for j in range(n)]
visit2 = [[False for i in range(m)]for j in range(n)]
dist1 = [[sys.maxsize for i in range(m)]for j in range(n)]
dist2 = [[sys.maxsize for i in range(m)]for j in range(n)]
if k1>=k2:
spaces(a,n,m,k1,visit1,visit2,dist1,[0,0])
else:
spaces(a,n,m,k2,visit1,visit2,dist1,[0,m-1])
listing = spaces(a,n,m,k1,visit2,visit1,dist2,[0,0])
if k1>k2:
listing = spaces(a,n,m,k2,visit2,visit1,dist2,[0,m-1])
#print visit1
#sprint visit2
if k1==k2:
if dist1[0][m-1]==sys.maxsize:
print('-1')
else:
print(int((dist1[0][m-1]+1)/2))
else:
d = len(listing)
for i in range(d-1,-1,-1):
x = listing[i][0]
y = listing[i][1]
if visit1[x][y]==True and dist2[x][y]<value:
value = dist2[x][y]
if value!=sys.maxsize:
print(value)
else:
print('-1')
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
In India, every individual is charged with income tax on the total income each year. This tax is applied to specific ranges of income, which are called income tax slabs. The slabs of income tax keep changing from year to year. This fiscal year (2020-21), the tax slabs and their respective tax rates are as follows:Total income (in rupees)Tax rateup to Rs. 250,0000%from Rs. 250,001 to Rs. 500,0005%from Rs. 500,001 to Rs. 750,00010%from Rs. 750,001 to Rs. 1,000,00015%from Rs. 1,000,001 to Rs. 1,250,00020%from Rs. 1,250,001 to Rs. 1,500,00025%above Rs. 1,500,00030%
See the sample explanation for details on how the income tax is calculated.
You are given Chef's total income: $N$ rupees (Rs.). Find his net income. The net income is calculated by subtracting the total tax (also called tax reduction) from the total income. Note that you do not need to worry about any other kind of tax reductions, only the one described above.
-----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 $N$.
-----Output-----
For each test case, print a single line containing one integer — Chef's net income.
-----Constraints-----
- $1 \le T \le 10^3$
- $0 \le N \le 10^7$
- $N$ is a multiple of $100$
-----Example Input-----
2
600000
250000
-----Example Output-----
577500
250000
-----Explanation-----
Example case 1: We know that the total income is Rs. $6$ lakh ($1$ lakh rupees = $10^5$ rupees). The total tax for each slab is calculated as follows:
- Up to $2.5$ lakh, the tax is Rs. $0$, since the tax rate is $0$ percent.
- From above Rs. $2.5$ lakh to Rs. $5$ lakh, the tax rate is $5$ percent. Therefore, this tax is $0.05 \cdot (500,000-250,000)$, which is Rs. $12,500$.
- From above Rs. $5$ lakh to Rs. $6$ lakh, the tax rate is $10$ percent. Therefore, this tax is $0.10 \cdot (600,000-500,000)$, which is Rs. $10,000$.
- Summing them up, we get that the total tax on Chef's whole income is Rs. $22,500$. Since the net income is the total income minus the tax reduction, it is Rs. $600,000$ minus Rs. $22,500$, which is Rs. $577,500$.
Example case 2: For income up to Rs. $2.5$ lakh, we have no tax, so the net income is the same as the total income: Rs. $2.5$ lakh.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
arr = [0]*6
arr[1] = 250000*(0.05)
arr[2] = 250000*(0.10)
arr[3] = 250000*(0.15)
arr[4] = 250000*(0.20)
arr[5] = 250000*(0.25)
for _ in range(int(input())):
n = int(input())
tax = 0
if n<=250000:
tax = 0
elif 250000<n<=500000:
tax = sum(arr[:1])
rem = n - 250000
tax+= (rem)*(0.05)
elif 500000<n<=750000:
tax = sum(arr[:2])
rem = n - 500000
tax+= (rem)*(0.10)
elif 750000<n<=1000000:
tax = sum(arr[:3])
rem = n - 750000
tax+= (rem)*(0.15)
elif 1000000<n<=1250000:
tax = sum(arr[:4])
rem = n - 1000000
tax+= (rem)*(0.20)
elif 1250000<n<=1500000:
tax = sum(arr[:5])
rem = n - 1250000
tax+= (rem)*(0.25)
elif n>1500000:
tax = sum(arr[:6])
rem = n - 1500000
tax+= (rem)*(0.30)
res = int(n - tax)
print(res)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Zonal Computing Olympiad 2012, 26 Nov 2011
The year is 2102 and today is the day of ZCO. This year there are N contests and the starting and ending times of each contest is known to you. You have to participate in exactly one of these contests. Different contests may overlap. The duration of different contests might be different.
There is only one examination centre. There is a wormhole V that transports you from your house to the examination centre and another wormhole W that transports you from the examination centre back to your house. Obviously, transportation through a wormhole does not take any time; it is instantaneous. But the wormholes can be used at only certain fixed times, and these are known to you.
So, you use a V wormhole to reach the exam centre, possibly wait for some time before the next contest begins, take part in the contest, possibly wait for some more time and then use a W wormhole to return back home. If you leave through a V wormhole at time t1 and come back through a W wormhole at time t2, then the total time you have spent is (t2 - t1 + 1). Your aim is to spend as little time as possible overall while ensuring
that you take part in one of the contests.
You can reach the centre exactly at the starting time of the contest, if possible. And you can leave the examination centre the very second the contest ends, if possible. You can assume that you will always be able to attend at least one contest–that is, there will always be a contest such that there is a V wormhole before it and a W wormhole after it.
For instance, suppose there are 3 contests with (start,end) times (15,21), (5,10), and (7,25), respectively. Suppose the V wormhole is available at times 4, 14, 25, 2 and the W wormhole is available at times 13 and 21. In this case, you can leave by the V wormhole at time 14, take part in the contest from time 15 to 21, and then use the W wormhole at time 21 to get back home. Therefore the time you have spent is (21 - 14 + 1) = 8. You can check that you cannot do better than this.
-----Input format-----
The first line contains 3 space separated integers N, X, and Y, where N is the number of contests, X is the number of time instances when wormhole V can be used and Y is the number of time instances when wormhole W can be used. The next N lines describe each contest. Each of these N lines contains two space separated integers S and E, where S is the starting time of the particular contest and E is the ending time of that contest, with S < E. The next line contains X space separated integers which are the time instances when the wormhole V can be used. The next line contains Y space separated integers which are the time instances when the wormhole W can be used.
-----Output format-----
Print a single line that contains a single integer, the minimum time needed to be spent to take part in a contest.
-----Testdata-----
All the starting and ending times of contests are distinct and no contest starts at the same time as another contest ends. The time instances when wormholes are available are all distinct, but may coincide with starting and ending times of contests. All the time instances (the contest timings and the wormhole timings) will be integers between 1 and 1000000 (inclusive).
- Subtask 1 (30 marks)
- Subtask 2 (70 marks)
You may assume that
1 ≤ N ≤ 105,
1 ≤ X ≤ 105, and
1 ≤ Y ≤ 105.
In 30% of the cases,
1 ≤ N ≤ 103,
1 ≤ X ≤ 103, and
1 ≤ Y ≤ 103.
-----Sample Input-----
3 4 2
15 21
5 10
7 25
4 14 25 2
13 21
-----Sample Output-----
8
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, x, y = input().split(' ')
n = int(n)
x = int(x)
y = int(y)
contests = {}
for i in range(n):
s, e = input().split(' ')
s = int(s)
e = int(e)
contests[(s, e)] = abs(s-e)
v_time = input().split(' ')
w_time = input().split(' ')
v_time, w_time = list(map(int, v_time)), list(map(int, w_time))
v_time.sort()
w_time.sort()
score = sys.maxsize
contests = dict(sorted(contests.items(), key=lambda item: item[1]))
for k, v in contests.items():
start=-1
end = sys.maxsize
for i in range(x):
if v_time[i] > k[0]:
break
start = v_time[i]
for j in range(y):
if w_time[j] >= k[1]:
end = w_time[j]
break
if start == -1:
continue
score = min(score, (end-start+1))
if score-1 <= v:
break
print(score)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Chef Ada is the FootBall coach of the Dinosaurs Institute of Technology.
There are $N$ dinosaurs (enumerated $1$ through $N$) placed in a line. The i-th dinosaur has a height of $i$ meters.
Ada is training The dinosaurs in the following tactic:
- Initially the leftmost dinosaur has the ball.
- The dinosaur that has the ball passes the ball to the nearest dinosaur to the right that is tallest than him.
- The previous step continues until the ball reaches the tallest dinosaur, then he throws the ball and scores a goal!
Help Ada reordering the dinosaurs in such a way that the ball is passed from dinosaur to dinosaur exactly $K$ times.
For example, if there are $5$ dinosaurs ordered as $[2,3,1,5,4]$, then the ball goes $2 \rightarrow 3\rightarrow5 \rightarrow goal$, and the ball was passed two times.
-----Input:-----
- First line will contain $T$, number of testcases.
- Each test case consist of a line with two space separated integers $N,K$.
-----Output:-----
For each testcase, output in a single line conaining $N$ integers representing one possible ordering in which the dinosaurs can be placed.
-----Constraints-----
- $1 \leq T \leq 2^8$
- $2 \leq N \leq 20$
- $0 \leq K \leq N-1$
-----Sample Input:-----
1
5 2
-----Sample Output:-----
2 3 1 5 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
t=int(input())
while t!=0:
n,k=map(int,input().split())
lst=[]
for i in range(1,n+1):
lst.append(i)
lst[k],lst[n-1]=lst[n-1],lst[k]
for item in lst:
print(item,end=' ')
t-=1
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
There exist certain strings, known as $Unique$ $Strings$. They possess a unique property:
- The character 'c' gets converted to "ff" and the character 'k' gets converted to "gg". Any letter besides 'c' and 'k' does not get converted to any other character.
Your job is to count the number of strings that could possibly be represented by a given unique string. Since the value could be very large, output the remainder when divided by $10^9+7$.
Note that if the given string is not a unique string, i.e. it contains either 'c' or 'k', output $0$.
-----Input:-----
- The first line of input contains a string, $s$.
-----Output:-----
- Output in a single line the possible number of strings modulo $10^9+7$.
-----Constraints-----
- $1 \leq |s| \leq 10^5$
where |s| denotes length of string.
-----Sample Input 1:-----
thing
-----Sample Input 2:-----
ggdffn
-----Sample Input 3:-----
fff
-----Sample Input 4:-----
cat
-----Sample Output 1:-----
1
-----Sample Output 2:-----
4
-----Sample Output 3:-----
3
-----Sample Output 4:-----
0
-----EXPLANATION:-----
The possible strings that can be represented by the given string in each of the examples are as follows:
$1)$ 'thing'
$2)$ 'ggdffn','kdffn','ggdcn','kdcn'
$3)$ 'fff','cf','fc'
$4)$ Since the string 'cat' contains 'c', it is certain that this string is not a unique string. Hence, the output is $0$.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
tb=str(input())
tb=list(tb)
if("c" in tb or "k" in tb):
print(0)
else:
ans=1
i=0
while(i<len(tb)):
if(tb[i]=="g" or tb[i]=="f"):
my=tb[i]
i+=1
ct=1
while(i<len(tb) and tb[i]==my):
ct+=1
i+=1
if(ct>3):
ct+=1
ans*=ct
else:
i+=1
print(ans)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Chef is in need of money, so he decided to play a game with Ramsay. In this game, there are $N$ rows of coins (numbered $1$ through $N$). For each valid $i$, the $i$-th row contains $C_i$ coins with values $A_{i, 1}, A_{i, 2}, \ldots, A_{i, C_i}$.
Chef and Ramsay alternate turns; Chef plays first. In each turns, the current player can choose one row that still contains coins and take one of the coins remaining in this row. Chef may only take the the first (leftmost) remaining coin in the chosen row, while Ramsay may only take the last (rightmost) remaining coin in the chosen row. The game ends when there are no coins left.
Each player wants to maximise the sum of values of the coins he took. Assuming that both Chef and Ramsay play optimally, what is the maximum amount of money (sum of values of coins) Chef can earn through this game?
-----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$.
- $N$ lines follow. For each valid $i$, the $i$-th of these lines contains an integer $C_i$, followed by a space and $C_i$ space-separated integers $A_{i, 1}, A_{i, 2}, \ldots, A_{i, C_i}$.
-----Output-----
For each test case, print a single line containing one integer ― the maximum amount of money Chef can earn.
-----Constraints-----
- $1 \le T \le 10$
- $1 \le N \le 10^4$
- $1 \le C_i \le 10$ for each valid $i$
- $1 \le A_{i, j} \le 10^5$ for each valid $i$ and $j$
-----Subtasks-----
Subtask #1 (20 points): $N = 1$
Subtask #2 (80 points): original constraints
-----Example Input-----
1
2
4 5 2 3 4
2 1 6
-----Example Output-----
8
-----Explanation-----
Example case 1: One optimal sequence of moves is: Chef takes the coin with value $5$, Ramsay takes $4$, Chef takes $2$, Ramsay takes $3$, Chef takes $1$ and Ramsay takes $6$. At the end, Chef has $5+2+1 = 8$ units of money.
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())
chef=0
ans=[]
for i in range(0,n):
l=list(map(int,input().split()))
c=l[0]
if c%2==0:
for i in range(1,len(l)//2+1):
chef=chef+l[i]
continue;
for i in range(1,len(l)//2):
chef=chef+l[i]
ans.append(l[len(l)//2])
ans.sort(reverse=True)
for i in range(len(ans)):
if i%2==0:
chef=chef+ans[i]
print(chef)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Chef likes problems related to learning new languages. He only knows first N letters of English alphabet. Also he explores all M-letter words formed by the characters he knows. Define cost for a given M-letter word S, cost(S) = P1, S1+P2, S2+...+PM, SM, where Pi, j is i, jth entry of matrix P. Sort all the words by descending cost, if costs are equal, sort them lexicographically. You need to find K-th M-letter word in Chef's order.
-----Input-----
First line contains three positive integer numbers N, M and K.
Next M lines contains N integers per line, denoting the matrix P.
-----Output-----
Output in a single line K-th M-letter in Chef's order.
-----Constraints-----
- 1 ≤ N ≤ 16
- 1 ≤ M ≤ 10
- 1 ≤ K ≤ NM
- 0 ≤ Pi, j ≤ 109
-----Subtasks-----
- Subtask #1: (20 points) 1 ≤ K ≤ 10000
- Subtask #2: (20 points) 1 ≤ M ≤ 5
- Subtask #3: (60 points) Original constraints
-----Example-----
Input:2 5 17
7 9
13 18
10 12
4 18
3 9
Output:aaaba
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
def dfs(ind,m,n,k):
if(ind == m):
return [""]
else:
temp = dfs(ind+1,m,n,k)
ans = []
if(len(temp)<k):
for i in temp:
for j in range(97,97+n):
ans += [chr(j)+i]
else:
for i in temp:
ans += ["z"+i]
return ans
n,m,k = list(map(int,input().split()))
p = []
mr= []
for _ in range(m):
inp = [int(x) for x in input().split()]
mc = inp[0]
mi = 0
for j in range(1,n):
if(mc<inp[j]):
mc = inp[j]
mi = j
p += [inp]
mr += [mi]
ans = dfs(0,m,n,k)
w = []
for i in ans:
cst = 0
s = ""
for j in range(m):
if(i[j]!="z"):
s+=i[j]
cst += p[j][ord(i[j])-97]
else:
s += chr(mr[j]+97)
w += [(-cst,s)]
w.sort()
print(w[k-1][1])
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
To protect people from evil,
a long and tall wall was constructed a few years ago.
But just a wall is not safe, there should also be soldiers on it,
always keeping vigil.
The wall is very long and connects the left and the right towers.
There are exactly N spots (numbered 1 to N) on the wall for soldiers.
The Kth spot is K miles far from the left tower and (N+1-K) miles from the right tower.
Given a permutation of spots P of {1, 2, ..., N}, soldiers occupy the N spots in that order.
The P[i]th spot is occupied before the P[i+1]th spot.
When a soldier occupies a spot, he is connected to his nearest soldier already placed to his left.
If there is no soldier to his left, he is connected to the left tower. The same is the case with right side.
A connection between two spots requires a wire of length equal to the distance between the two.
The realm has already purchased a wire of M miles long from Nokia,
possibly the wire will be cut into smaller length wires.
As we can observe, the total length of the used wire depends on the permutation of the spots P. Help the realm in minimizing the length of the unused wire. If there is not enough wire, output -1.
-----Input-----
First line contains an integer T (number of test cases, 1 ≤ T ≤ 10 ). Each of the next T lines contains two integers N M, as explained in the problem statement (1 ≤ N ≤ 30 , 1 ≤ M ≤ 1000).
-----Output-----
For each test case, output the minimum length of the unused wire, or -1 if the the wire is not sufficient.
-----Example-----
Input:
4
3 8
3 9
2 4
5 25
Output:
0
0
-1
5
Explanation:
In the 1st case, for example, the permutation P = {2, 1, 3} will use the exact 8 miles wires in total.
In the 2nd case, for example, the permutation P = {1, 3, 2} will use the exact 9 miles wires in total.
To understand the first two cases, you can see the following figures:
In the 3rd case, the minimum length of wire required is 5, for any of the permutations {1,2} or {2,1}, so length 4 is not sufficient.
In the 4th case, for the permutation {1, 2, 3, 4, 5} we need the maximum length of the wire = 20. So minimum possible unused wire length = 25 - 20 = 5.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
D=[0]*31
D[1]=2
D[2]=5
for i in range(3,31):
best=10**10
for p in range(1,i+1):
best=min(best,D[p-1]+D[i-p]+i+1)
D[i]=best
t=int(input())
for i in range(t):
n,m=list(map(int,input().split()))
maxi=(n+2)*(n+1)/2-1
mini=D[n]
if mini<=m<=maxi: print(0)
elif m<mini: print(-1)
else: print(m-maxi)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
There are some websites that are accessible through several different addresses. For example, for a long time Codeforces was accessible with two hostnames codeforces.com and codeforces.ru.
You are given a list of page addresses being queried. For simplicity we consider all addresses to have the form http://<hostname>[/<path>], where:
<hostname> — server name (consists of words and maybe some dots separating them), /<path> — optional part, where <path> consists of words separated by slashes.
We consider two <hostname> to correspond to one website if for each query to the first <hostname> there will be exactly the same query to the second one and vice versa — for each query to the second <hostname> there will be the same query to the first one. Take a look at the samples for further clarifications.
Your goal is to determine the groups of server names that correspond to one website. Ignore groups consisting of the only server name.
Please note, that according to the above definition queries http://<hostname> and http://<hostname>/ are different.
-----Input-----
The first line of the input contains a single integer n (1 ≤ n ≤ 100 000) — the number of page queries. Then follow n lines each containing exactly one address. Each address is of the form http://<hostname>[/<path>], where:
<hostname> consists of lowercase English letters and dots, there are no two consecutive dots, <hostname> doesn't start or finish with a dot. The length of <hostname> is positive and doesn't exceed 20. <path> consists of lowercase English letters, dots and slashes. There are no two consecutive slashes, <path> doesn't start with a slash and its length doesn't exceed 20.
Addresses are not guaranteed to be distinct.
-----Output-----
First print k — the number of groups of server names that correspond to one website. You should count only groups of size greater than one.
Next k lines should contain the description of groups, one group per line. For each group print all server names separated by a single space. You are allowed to print both groups and names inside any group in arbitrary order.
-----Examples-----
Input
10
http://abacaba.ru/test
http://abacaba.ru/
http://abacaba.com
http://abacaba.com/test
http://abacaba.de/
http://abacaba.ru/test
http://abacaba.de/test
http://abacaba.com/
http://abacaba.com/t
http://abacaba.com/test
Output
1
http://abacaba.de http://abacaba.ru
Input
14
http://c
http://ccc.bbbb/aba..b
http://cba.com
http://a.c/aba..b/a
http://abc/
http://a.c/
http://ccc.bbbb
http://ab.ac.bc.aa/
http://a.a.a/
http://ccc.bbbb/
http://cba.com/
http://cba.com/aba..b
http://a.a.a/aba..b/a
http://abc/aba..b/a
Output
2
http://cba.com http://ccc.bbbb
http://a.a.a http://a.c http://abc
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
# Bartek Kostka
# You are not prepared!
#include "bits/stdc++.h"
n = int(input())
W = {}
for i in range(n):
adr = input()
adr = adr.split("/")
if adr[-1] == '':
adr[-1] = '?'
domena = "/".join(adr[:3])
adres = "/".join(adr[3:])
#print(domena, adres)
if domena not in W:
W[domena] = set()
W[domena].add(adres)
E = {}
for key, ele in list(W.items()):
#print(key, ele)
lele = "#".join(sorted(list(ele)))
if lele not in E:
E[lele] = []
E[lele].append(key)
res = 0
for key, ele in list(E.items()):
if len(ele) > 1:
res += 1
print(res)
for key, ele in list(E.items()):
if len(ele) > 1:
print(" ".join(ele))
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
You are given $n$ strings $a_1, a_2, \ldots, a_n$: all of them have the same length $m$. The strings consist of lowercase English letters.
Find any string $s$ of length $m$ such that each of the given $n$ strings differs from $s$ in at most one position. Formally, for each given string $a_i$, there is no more than one position $j$ such that $a_i[j] \ne s[j]$.
Note that the desired string $s$ may be equal to one of the given strings $a_i$, or it may differ from all the given strings.
For example, if you have the strings abac and zbab, then the answer to the problem might be the string abab, which differs from the first only by the last character, and from the second only by the first.
-----Input-----
The first line contains an integer $t$ ($1 \le t \le 100$) — the number of test cases. Then $t$ test cases follow.
Each test case starts with a line containing two positive integers $n$ ($1 \le n \le 10$) and $m$ ($1 \le m \le 10$) — the number of strings and their length.
Then follow $n$ strings $a_i$, one per line. Each of them has length $m$ and consists of lowercase English letters.
-----Output-----
Print $t$ answers to the test cases. Each answer (if it exists) is a string of length $m$ consisting of lowercase English letters. If there are several answers, print any of them. If the answer does not exist, print "-1" ("minus one", without quotes).
-----Example-----
Input
5
2 4
abac
zbab
2 4
aaaa
bbbb
3 3
baa
aaa
aab
2 2
ab
bb
3 1
a
b
c
Output
abab
-1
aaa
ab
z
-----Note-----
The first test case was explained in the statement.
In the second test case, the answer does not exist.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
def isvalid(s):
nonlocal l
for i in l:
count=0
for j in range(len(i)):
if(s[j]!=i[j]):
count+=1
if(count>1):
return 0
return 1
t=int(input())
for you in range(t):
l=input().split()
n=int(l[0])
m=int(l[1])
l=[]
for i in range(n):
s=input()
l.append(s)
poss=0
ans=0
for i in range(m):
copy=[x for x in l[0]]
for j in range(26):
copy[i]=chr(97+j)
if(isvalid(copy)):
poss=1
ans=copy
break
if(poss==1):
break
if(poss):
for i in ans:
print(i,end="")
print()
else:
print(-1)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
This is a peculiar functioning setup.
Two Tanks are separated from each other by a wall .There is a pipe in the wall which connects both tanks which allows flow of water between them . Due to this ,there is change in temperature of both tanks , every minute temperature of Tank with larger temperature among two decreases by one and temperature of Tank with smaller temperature among two increases by two until equilibrium is reached , But there is a problem .
The pipe can't control this flow of water if there is Non-equilibrium (inequality of temperature on both sides ) even after $m$ minutes and the pipe will burst after it , your task is to predict whether the pipe will burst or not .
Note: If equilibrium cannot be reached the process will continue forever.
The initial temperature of Cold Tank is $Tc$ , of Hot Tank it is $Th$.
-----Input:-----
- First line will contain $T$, number of testcases. Then the testcases follow.
- Each testcase contains of a single line of input, three integers $m, Tc,Th$.
-----Output:-----
For each testcase, output in a single line answer "Yes" if Pipe will burst after m minutes "No" if pipe will not burst.
-----Constraints-----
- $1 \leq T \leq 100000$
- $1 \leq m,Tc,Th \leq 10^9$
- $Tc \leq Th $
-----Sample Input:-----
2
4 5 10
2 2 5
-----Sample 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
for i in range(int(input())):
m,tc,th=map(int,input().split())
x=(th-tc)
if x%3!=0:
print("Yes")
else:
if (x//3)<=m:
print("No")
else:
print("Yes")
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Alex decided to go on a touristic trip over the country.
For simplicity let's assume that the country has $n$ cities and $m$ bidirectional roads connecting them. Alex lives in city $s$ and initially located in it. To compare different cities Alex assigned each city a score $w_i$ which is as high as interesting city seems to Alex.
Alex believes that his trip will be interesting only if he will not use any road twice in a row. That is if Alex came to city $v$ from city $u$, he may choose as the next city in the trip any city connected with $v$ by the road, except for the city $u$.
Your task is to help Alex plan his city in a way that maximizes total score over all cities he visited. Note that for each city its score is counted at most once, even if Alex been there several times during his trip.
-----Input-----
First line of input contains two integers $n$ and $m$, ($1 \le n \le 2 \cdot 10^5$, $0 \le m \le 2 \cdot 10^5$) which are numbers of cities and roads in the country.
Second line contains $n$ integers $w_1, w_2, \ldots, w_n$ ($0 \le w_i \le 10^9$) which are scores of all cities.
The following $m$ lines contain description of the roads. Each of these $m$ lines contains two integers $u$ and $v$ ($1 \le u, v \le n$) which are cities connected by this road.
It is guaranteed that there is at most one direct road between any two cities, no city is connected to itself by the road and, finally, it is possible to go from any city to any other one using only roads.
The last line contains single integer $s$ ($1 \le s \le n$), which is the number of the initial city.
-----Output-----
Output single integer which is the maximum possible sum of scores of visited cities.
-----Examples-----
Input
5 7
2 2 8 6 9
1 2
1 3
2 4
3 2
4 5
2 5
1 5
2
Output
27
Input
10 12
1 7 1 9 3 3 6 30 1 10
1 2
1 3
3 5
5 7
2 3
5 4
6 9
4 6
3 7
6 8
9 4
9 10
6
Output
61
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,m=list(map(int,input().split()))
W=[0]+list(map(int,input().split()))
E=[tuple(map(int,input().split())) for i in range(m)]
S=int(input())
ELIST=[[] for i in range(n+1)]
EW=[0]*(n+1)
for x,y in E:
ELIST[x].append(y)
ELIST[y].append(x)
EW[x]+=1
EW[y]+=1
from collections import deque
Q=deque()
USED=[0]*(n+1)
for i in range(1,n+1):
if EW[i]==1 and i!=S:
USED[i]=1
Q.append(i)
EW[S]+=1<<50
USED[S]=1
while Q:
x=Q.pop()
EW[x]-=1
for to in ELIST[x]:
if USED[to]==1:
continue
EW[to]-=1
if EW[to]==1 and USED[to]==0:
Q.append(to)
USED[to]=1
#print(EW)
LOOP=[]
ANS=0
for i in range(1,n+1):
if EW[i]!=0:
ANS+=W[i]
LOOP.append(i)
SCORE=[0]*(n+1)
USED=[0]*(n+1)
for l in LOOP:
SCORE[l]=ANS
USED[l]=1
Q=deque(LOOP)
while Q:
x=Q.pop()
for to in ELIST[x]:
if USED[to]==1:
continue
SCORE[to]=W[to]+SCORE[x]
Q.append(to)
USED[to]=1
print(max(SCORE))
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Due to COVID19 all employees of chemical factory are quarantined in home. So, company is organized by automated robots. There are $N$ Containers in company, which are labelled with $1$ to $N$ numbers. There are Total $N$ robots in Company, which are labelled $1$ to $N$.
Each Robot adds $1$ litter Chemical in containers whose labels are multiple of robots’ label. (E.g. robot labelled 2 will add Chemical in containers labelled 2, 4, 6, ….).
Robots follow few rules mentioned below:
- Chemical with $pH<7$ is acidic.
- Chemical with $pH=7$ is neutral.
- Chemical with $pH>7$ is basic.
- Mixture of $1$ litter acid and $1$ litter base makes neutral solution.
- If Container is empty or pH of Chemical in container is equal to
- $7$ then robot adds $1$ litter acidic Chemical.
- If pH of Chemical in container is less than $7$ then robots adds $1$ litter basic Chemical.
Now Chemical is packed in $4$ ways:
- Containers with exactly $2$ litter acid and $1$ litter base are packed at $P1$ cost.
- Containers with acidic Chemical are packed at $P2$ cost. (Here Don’t consider containers with exactly $2$ litter acid and $1$ litter base as we counted them in above rule)
- Containers with $pH=7$ Chemical is packed at $P3$ cost.
- Containers with Basic Chemical are packed at $P4$ cost.
Now $1$ employee given task to find packing cost of containers with labels in range $[ k1, k2]$ (Inclusive). Help him out. As Cost can be large find cost in modulo of $100000007$
-----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 $3$ space separated Integers $N$, $K1$ and $K2$.
- The second and last line contains $4$ space separated Integers $P1$, $P2$, $P3$ and $P4$
-----Output:-----
For each test case, print total cost of packing of containers modulo 100000007.
-----Constraints-----
- $1 \leq T \leq 50000$
- $1 \leq P1, P2, P3, P4 \leq 2*10^7$
- $2 \leq N \leq 2*10^7$
- $1 \leq K1, K2 \leq N$
-----Subtasks-----Subtask #1 (20 points):
- $1 \leq T \leq 10$
- $1 \leq P1, P2, P3, P4 \leq 2*10^7$
- $2 \leq N \leq 1000$
- $1 \leq K1, K2 \leq N$Subtask #2 (80 points) :
- Original Constraint
-----Sample Input:-----
1
4 1 4
2 2 2 2
-----Sample Output:-----
8
-----Explanation:-----
Let’s use notation,
0 for acidic Chemical,
1 for Chemical with pH=7,
2 for basic Chemical,
3 for Containers with exactly 2 litter acid and 1 litter base,
-1 for empty containers
Initially 4 containers are empty so
[-1, -1, -1, -1]
Robot 1 adds 1 litter acid in all containers.
[0, 0, 0, 0]
Robot 2 adds base in containers labelled 2, 4
[0, 1, 0, 1]
Robot 3 adds base in containers labelled 3
[0, 1, 1, 1]
Robot 4 adds acid in containers labelled 4 because it contains Chemical with pH=7. After adding acid, it also contains exactly 2 litter acid and 1 litter base, so denoting it with 3.
[0, 1, 1, 3]
Corresponding cost of packing container
[P2, P3, P3, P1]
Now, calculate total cost,
Cost = P2+P3+P3+P1 = 2+2+2+2 = 8
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, K1, K2 = list(map(int, input().split()))
P1, P2, P3, P4 = list(map(int, input().split()))
ans = 0
arr = [0] * (1005)
length = len(arr)
for i in range(1,N+1):
j = 0
while j < length:
arr[j] += 1
j += i
for i in range(K1,K2+1):
if arr[i]==3:
ans += P1
elif arr[i]%2==1:
ans += P2
else:
ans += P3
print(ans)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Given a permutation $p$ of length $n$, find its subsequence $s_1$, $s_2$, $\ldots$, $s_k$ of length at least $2$ such that: $|s_1-s_2|+|s_2-s_3|+\ldots+|s_{k-1}-s_k|$ is as big as possible over all subsequences of $p$ with length at least $2$. Among all such subsequences, choose the one whose length, $k$, is as small as possible.
If multiple subsequences satisfy these conditions, you are allowed to find any of them.
A sequence $a$ is a subsequence of an array $b$ if $a$ can be obtained from $b$ by deleting some (possibly, zero or all) elements.
A permutation of length $n$ is an array of length $n$ in which every element from $1$ to $n$ occurs exactly once.
-----Input-----
The first line contains an integer $t$ ($1 \le t \le 2 \cdot 10^4$) — the number of test cases. The description of the test cases follows.
The first line of each test case contains an integer $n$ ($2 \le n \le 10^5$) — the length of the permutation $p$.
The second line of each test case contains $n$ integers $p_1$, $p_2$, $\ldots$, $p_{n}$ ($1 \le p_i \le n$, $p_i$ are distinct) — the elements of the permutation $p$.
The sum of $n$ across the test cases doesn't exceed $10^5$.
-----Output-----
For each test case, the first line should contain the length of the found subsequence, $k$. The second line should contain $s_1$, $s_2$, $\ldots$, $s_k$ — its elements.
If multiple subsequences satisfy these conditions, you are allowed to find any of them.
-----Example-----
Input
2
3
3 2 1
4
1 3 4 2
Output
2
3 1
3
1 4 2
-----Note-----
In the first test case, there are $4$ subsequences of length at least $2$: $[3,2]$ which gives us $|3-2|=1$. $[3,1]$ which gives us $|3-1|=2$. $[2,1]$ which gives us $|2-1|=1$. $[3,2,1]$ which gives us $|3-2|+|2-1|=2$.
So the answer is either $[3,1]$ or $[3,2,1]$. Since we want the subsequence to be as short as possible, the answer is $[3,1]$.
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, x = map(int, input().split())
n = int(input())
arr = list(map(int, input().split()))
ans = [arr[0]]
for i in range(1, n - 1):
if arr[i - 1] < arr[i] and arr[i] > arr[i + 1]:
ans.append(arr[i])
elif arr[i - 1] > arr[i] and arr[i] < arr[i + 1]:
ans.append(arr[i])
ans.append(arr[-1])
print(len(ans))
print(*ans)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Recently, Dima met with Sasha in a philatelic store, and since then they are collecting coins together. Their favorite occupation is to sort collections of coins. Sasha likes having things in order, that is why he wants his coins to be arranged in a row in such a way that firstly come coins out of circulation, and then come coins still in circulation.
For arranging coins Dima uses the following algorithm. One step of his algorithm looks like the following:
He looks through all the coins from left to right; If he sees that the i-th coin is still in circulation, and (i + 1)-th coin is already out of circulation, he exchanges these two coins and continues watching coins from (i + 1)-th.
Dima repeats the procedure above until it happens that no two coins were exchanged during this procedure. Dima calls hardness of ordering the number of steps required for him according to the algorithm above to sort the sequence, e.g. the number of times he looks through the coins from the very beginning. For example, for the ordered sequence hardness of ordering equals one.
Today Sasha invited Dima and proposed him a game. First he puts n coins in a row, all of them are out of circulation. Then Sasha chooses one of the coins out of circulation and replaces it with a coin in circulation for n times. During this process Sasha constantly asks Dima what is the hardness of ordering of the sequence.
The task is more complicated because Dima should not touch the coins and he should determine hardness of ordering in his mind. Help Dima with this task.
-----Input-----
The first line contains single integer n (1 ≤ n ≤ 300 000) — number of coins that Sasha puts behind Dima.
Second line contains n distinct integers p_1, p_2, ..., p_{n} (1 ≤ p_{i} ≤ n) — positions that Sasha puts coins in circulation to. At first Sasha replaces coin located at position p_1, then coin located at position p_2 and so on. Coins are numbered from left to right.
-----Output-----
Print n + 1 numbers a_0, a_1, ..., a_{n}, where a_0 is a hardness of ordering at the beginning, a_1 is a hardness of ordering after the first replacement and so on.
-----Examples-----
Input
4
1 3 4 2
Output
1 2 3 2 1
Input
8
6 8 3 4 7 2 1 5
Output
1 2 2 3 4 3 4 5 1
-----Note-----
Let's denote as O coin out of circulation, and as X — coin is circulation.
At the first sample, initially in row there are coins that are not in circulation, so Dima will look through them from left to right and won't make any exchanges.
After replacement of the first coin with a coin in circulation, Dima will exchange this coin with next three times and after that he will finally look through the coins and finish the process.
XOOO → OOOX
After replacement of the third coin, Dima's actions look this way:
XOXO → OXOX → OOXX
After replacement of the fourth coin, Dima's actions look this way:
XOXX → OXXX
Finally, after replacement of the second coin, row becomes consisting of coins that are in circulation and Dima will look through coins from left to right without any exchanges.
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 = list(map(int, input().split()))
p = [0] * (n + 1)
ans = [1] * (n + 1)
ind = n
for i in range(n):
p[a[i] - 1] = 1
while ind > 0 and p[ind - 1] == 1:
ind -= 1
ans[i + 1] = 1 + (i + 1) - (n - ind)
print(' '.join(map(str, ans)))
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
The mayor of the Central Town wants to modernize Central Street, represented in this problem by the $(Ox)$ axis.
On this street, there are $n$ antennas, numbered from $1$ to $n$. The $i$-th antenna lies on the position $x_i$ and has an initial scope of $s_i$: it covers all integer positions inside the interval $[x_i - s_i; x_i + s_i]$.
It is possible to increment the scope of any antenna by $1$, this operation costs $1$ coin. We can do this operation as much as we want (multiple times on the same antenna if we want).
To modernize the street, we need to make all integer positions from $1$ to $m$ inclusive covered by at least one antenna. Note that it is authorized to cover positions outside $[1; m]$, even if it's not required.
What is the minimum amount of coins needed to achieve this modernization?
-----Input-----
The first line contains two integers $n$ and $m$ ($1 \le n \le 80$ and $n \le m \le 100\ 000$).
The $i$-th of the next $n$ lines contains two integers $x_i$ and $s_i$ ($1 \le x_i \le m$ and $0 \le s_i \le m$).
On each position, there is at most one antenna (values $x_i$ are pairwise distinct).
-----Output-----
You have to output a single integer: the minimum amount of coins required to make all integer positions from $1$ to $m$ inclusive covered by at least one antenna.
-----Examples-----
Input
3 595
43 2
300 4
554 10
Output
281
Input
1 1
1 1
Output
0
Input
2 50
20 0
3 1
Output
30
Input
5 240
13 0
50 25
60 5
155 70
165 70
Output
26
-----Note-----
In the first example, here is a possible strategy:
Increase the scope of the first antenna by $40$, so that it becomes $2 + 40 = 42$. This antenna will cover interval $[43 - 42; 43 + 42]$ which is $[1; 85]$ Increase the scope of the second antenna by $210$, so that it becomes $4 + 210 = 214$. This antenna will cover interval $[300 - 214; 300 + 214]$, which is $[86; 514]$ Increase the scope of the third antenna by $31$, so that it becomes $10 + 31 = 41$. This antenna will cover interval $[554 - 41; 554 + 41]$, which is $[513; 595]$
Total cost is $40 + 210 + 31 = 281$. We can prove that it's the minimum cost required to make all positions from $1$ to $595$ covered by at least one antenna.
Note that positions $513$ and $514$ are in this solution covered by two different antennas, but it's not important.
—
In the second example, the first antenna already covers an interval $[0; 2]$ so we have nothing to do.
Note that the only position that we needed to cover was position $1$; positions $0$ and $2$ are covered, but it's not important.
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,m=list(map(int,input().split()))
A=[]
COVERED=[0]*(m+1)
for i in range(n):
x,y=list(map(int,input().split()))
A.append((x-y,x+y))
for j in range(max(0,x-y),min(m+1,x+y+1)):
COVERED[j]=1
if min(COVERED[1:])==1:
print(0)
return
A.sort()
DP=[m]*(m+2)
DP[1]=0
covind=1
while COVERED[covind]==1:
DP[covind]=0
covind+=1
DP[covind]=0
NEXT=[i+1 for i in range(m+1)]
for j in range(m-1,-1,-1):
if COVERED[j+1]==1:
NEXT[j]=NEXT[j+1]
def nex(i):
if i<=m:
return NEXT[i]
else:
return m+1
for i in range(1,m+1):
if COVERED[i]==1:
continue
for x,y in A:
if x<i:
continue
DP[nex(y+(x-i))]=min(DP[i]+(x-i),DP[nex(y+(x-i))])
#print(DP)
ANS=DP[-1]
for i in range(m,-1,-1):
if DP[i]!=m+1:
ANS=(min(ANS,DP[i]+(m+1-i)))
print(ANS)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
You are given a string s consisting of n lowercase Latin letters. You have to type this string using your keyboard.
Initially, you have an empty string. Until you type the whole string, you may perform the following operation: add a character to the end of the string.
Besides, at most once you may perform one additional operation: copy the string and append it to itself.
For example, if you have to type string abcabca, you can type it in 7 operations if you type all the characters one by one. However, you can type it in 5 operations if you type the string abc first and then copy it and type the last character.
If you have to type string aaaaaaaaa, the best option is to type 4 characters one by one, then copy the string, and then type the remaining character.
Print the minimum number of operations you need to type the given string.
-----Input-----
The first line of the input containing only one integer number n (1 ≤ n ≤ 100) — the length of the string you have to type. The second line containing the string s consisting of n lowercase Latin letters.
-----Output-----
Print one integer number — the minimum number of operations you need to type the given string.
-----Examples-----
Input
7
abcabca
Output
5
Input
8
abcdefgh
Output
8
-----Note-----
The first test described in the problem statement.
In the second test you can only type all the characters one by one.
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())
st = input()
ans = n
now = ''
ma = 0
for i in range(n // 2):
now += st[i]
t = ''
for j in range(i + 1, 2 * i + 2):
t += st[j]
if t == now:
ma = i
print(ans - ma)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Given an array $A$ of length $N$.
We have to find the $maximum$ sum of elements of the subarray between $two$ nearest occurrences of $same$ elements (excluding both).
If both the elements are $even$ then the total number of $even$ elements in that subarray should be $even$ then and then only we consider that subarray and if both the elements are $odd$ then the total number of $odd$ element in that subarray should be $odd$ then and then only we consider that subarray.
If the condition never matches print $0$.
-----Input:-----
- First line contains $T$, number of test cases. Then the test cases follow.
- Each testcase consists of two lines:
The first line has $N$ : number of elements in the array and second-line has $N$ space separated integers: elements of the array.
-----Output:-----
- For each test case, output in a single line $maximum$ sum.
-----Constraints-----
- $1 \leq T \leq 10$
- $3 \leq N \leq 2*10^5$
- $1 \leq A[i] \leq 10^8$
$NOTE $: Use of Fast Input Output is recommended.
-----Sample Input:-----
1
10
1 2 3 2 1 5 1 2 8 2
-----Sample Output:-----
7
-----EXPLANATION:-----
The maximum sum is 7, between 1 at 1st position and 1 at 5th position i.e sum of 2,3,2
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
from collections import defaultdict
for _ in range(int(stdin.readline())):
n=int(stdin.readline())
lst=list(map(int, stdin.readline().split()))
prefix_odd=[0]*n
prefix_even=[0]*n
odd_val=0
even_val=0
for i in range(n):
if lst[i]%2==0:
even_val+=1
else:
odd_val+=1
prefix_even[i]=even_val
prefix_odd[i]=odd_val
#print(prefix_odd,prefix_even)
prefix_sum=[0]*n
s=0
for i in range(n):
s+=lst[i]
prefix_sum[i]=s
#print(prefix_sum)
dict={}
count={}
for i in range(n):
if lst[i] not in dict:
dict[lst[i]]=i
count[lst[i]]=1
else:
dict[lst[i]]=i
count[lst[i]]+=1
#print(dict)
graph=defaultdict(list)
for i in range(n):
graph[lst[i]].append(i)
max_sum=0
for i in graph:
if len(graph[i])>1:
prev=graph[i][0]
for j in range(1,len(graph[i])):
index2=graph[i][j]
index1=prev
prev=index2
#print(index1,index2)
if i%2==0:
val=prefix_even[index2]-prefix_even[index1]-1
#print(val)
if val%2==0:
temp_sum=prefix_sum[index2]-prefix_sum[index1]-i
#print(temp_sum)
if temp_sum>max_sum:
max_sum=temp_sum
else:
val=prefix_odd[index2]-prefix_odd[index1]-1
#print(val)
if val%2!=0:
temp_sum=prefix_sum[index2]-prefix_sum[index1]-i
#print(temp_sum)
if temp_sum>max_sum:
max_sum=temp_sum
'''max_sum=-1
for i in range(n):
if count[lst[i]]>1:
index2=dict[lst[i]]
index1=i
print(index1,index2)
if lst[i]%2==0:
val=prefix_even[index2]-prefix_even[index1]-1
print(val)
if val%2==0:
temp_sum=prefix_sum[index2]-prefix_sum[index1]-lst[i]
print(temp_sum)
if temp_sum>max_sum:
max_sum=temp_sum
else:
val=prefix_odd[index2]-prefix_odd[index1]-1
print(val)
if val%2!=0:
temp_sum=prefix_sum[index2]-prefix_sum[index1]-lst[i]
print(temp_sum)
if temp_sum>max_sum:
max_sum=temp_sum'''
stdout.write(str(max_sum)+'\n')
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Chef recently graduated Computer Science in university, so he was looking for a job. He applied for several job offers, but he eventually settled for a software engineering job at ShareChat. Chef was very enthusiastic about his new job and the first mission assigned to him was to implement a message encoding feature to ensure the chat is private and secure.
Chef has a message, which is a string $S$ with length $N$ containing only lowercase English letters. It should be encoded in two steps as follows:
- Swap the first and second character of the string $S$, then swap the 3rd and 4th character, then the 5th and 6th character and so on. If the length of $S$ is odd, the last character should not be swapped with any other.
- Replace each occurrence of the letter 'a' in the message obtained after the first step by the letter 'z', each occurrence of 'b' by 'y', each occurrence of 'c' by 'x', etc, and each occurrence of 'z' in the message obtained after the first step by 'a'.
The string produced in the second step is the encoded message. Help Chef and find this message.
-----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 the message string $S$.
-----Output-----
For each test case, print a single line containing one string — the encoded message.
-----Constraints-----
- $1 \le T \le 1,000$
- $1 \le N \le 100$
- $|S| = N$
- $S$ contains only lowercase English letters
-----Example Input-----
2
9
sharechat
4
chef
-----Example Output-----
shizxvzsg
sxuv
-----Explanation-----
Example case 1: The original message is "sharechat". In the first step, we swap four pairs of letters (note that the last letter is not swapped), so it becomes "hsraceaht". In the second step, we replace the first letter ('h') by 's', the second letter ('s') by 'h', and so on, so the resulting encoded message is "shizxvzsg".
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
try:
for _ in range(int(input())):
n = int(input())
li = [i for i in input()]
a = 0
while a+1<len(li):
li[a],li[a+1] = li[a+1],li[a]
a+=2
li2 = li.copy()
for i in li2:
fh = 109
sh = 110
li.remove(i)
if ord(i)>fh:
li.append(chr(fh-(ord(i)-sh)))
else:
li.append(chr(sh+(fh-ord(i))))
for i in li:
print(i,end="")
print()
except:
pass
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Let's look at the following process: initially you have an empty stack and an array $s$ of the length $l$. You are trying to push array elements to the stack in the order $s_1, s_2, s_3, \dots s_{l}$. Moreover, if the stack is empty or the element at the top of this stack is not equal to the current element, then you just push the current element to the top of the stack. Otherwise, you don't push the current element to the stack and, moreover, pop the top element of the stack.
If after this process the stack remains empty, the array $s$ is considered stack exterminable.
There are samples of stack exterminable arrays: $[1, 1]$; $[2, 1, 1, 2]$; $[1, 1, 2, 2]$; $[1, 3, 3, 1, 2, 2]$; $[3, 1, 3, 3, 1, 3]$; $[3, 3, 3, 3, 3, 3]$; $[5, 1, 2, 2, 1, 4, 4, 5]$;
Let's consider the changing of stack more details if $s = [5, 1, 2, 2, 1, 4, 4, 5]$ (the top of stack is highlighted). after pushing $s_1 = 5$ the stack turn into $[\textbf{5}]$; after pushing $s_2 = 1$ the stack turn into $[5, \textbf{1}]$; after pushing $s_3 = 2$ the stack turn into $[5, 1, \textbf{2}]$; after pushing $s_4 = 2$ the stack turn into $[5, \textbf{1}]$; after pushing $s_5 = 1$ the stack turn into $[\textbf{5}]$; after pushing $s_6 = 4$ the stack turn into $[5, \textbf{4}]$; after pushing $s_7 = 4$ the stack turn into $[\textbf{5}]$; after pushing $s_8 = 5$ the stack is empty.
You are given an array $a_1, a_2, \ldots, a_n$. You have to calculate the number of its subarrays which are stack exterminable.
Note, that you have to answer $q$ independent queries.
-----Input-----
The first line contains one integer $q$ ($1 \le q \le 3 \cdot 10^5$) — the number of queries.
The first line of each query contains one integer $n$ ($1 \le n \le 3 \cdot 10^5$) — the length of array $a$.
The second line of each query contains $n$ integers $a_1, a_2, \ldots, a_n$ ($1 \le a_i \le n$) — the elements.
It is guaranteed that the sum of all $n$ over all queries does not exceed $3 \cdot 10^5$.
-----Output-----
For each test case print one integer in single line — the number of stack exterminable subarrays of the array $a$.
-----Example-----
Input
3
5
2 1 1 2 2
6
1 2 1 1 3 2
9
3 1 2 2 1 6 6 3 3
Output
4
1
8
-----Note-----
In the first query there are four stack exterminable subarrays: $a_{1 \ldots 4} = [2, 1, 1, 2], a_{2 \ldots 3} = [1, 1], a_{2 \ldots 5} = [1, 1, 2, 2], a_{4 \ldots 5} = [2, 2]$.
In the second query, only one subarray is exterminable subarray — $a_{3 \ldots 4}$.
In the third query, there are eight stack exterminable subarrays: $a_{1 \ldots 8}, a_{2 \ldots 5}, a_{2 \ldots 7}, a_{2 \ldots 9}, a_{3 \ldots 4}, a_{6 \ldots 7}, a_{6 \ldots 9}, a_{8 \ldots 9}$.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
# encoding: utf-8
from sys import stdin
def solve(a):
# root node of tries denotes empty stack
stack = [None]
node_stack = [[1, {}]]
trie = node_stack[-1]
counter = 0
for i in range(len(a)):
el = a[i]
if len(stack) == 0 or stack[-1] != el:
current_node = node_stack[-1]
stack.append(el)
if el not in current_node[1]:
current_node[1][el] = [0, {}]
next_node = current_node[1][el]
next_node[0] += 1
node_stack.append(next_node)
else:
# just go up in trie
stack.pop()
node_stack.pop()
node_stack[-1][0] += 1
value = node_stack[-1][0]
counter -= (((value - 1) * (value - 2)) // 2)
counter += (((value) * (value - 1)) // 2)
return counter
q = int(stdin.readline().strip())
for _ in range(q):
n = int(stdin.readline().strip())
a = [int(i) for i in stdin.readline().strip().split()]
print(solve(a))
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Sherlock Holmes has decided to start a new academy to some of the young lads. He has conducted several tests and finally selected N equally brilliant
students.Now he don't know whether to train all the N students or not. Now since Holmes was in a confusion, Watson came up with an idea. He wanted to
test the obedience of the students. So during the camp, the students were given some Swiss Chocolates as gifts each time when they passed a level.Now some of them have
finished eating all the chocolates, some of them had some remaining. Now to test their team chemistry and IQ skills, Watson told the lads to arrange themselves in such
a way that, number of chocolates of the ith kid should be equal to the sum of (i-1)th kid and (i-2)th kid. Now they have arranged themselves in an order.
Now Sherlock announced that he will select the students who have formed the line according to this order. But since there can be many such small groups among the
entire N kids, he will select a sequence of kids such that the length of the sequence is maximized, meanwhile satisfying the above condition
-----Input-----
First line is an integer T which denotes the total number of test cases. Each of the next T lines contains an integer N which denotes, N students. The next
line contains N spaced integers.where it denotes the order in which the kids arranged themselves.
-----Output-----
Each line contains an integer which denotes the maximum number of students among the N students who have arranged themselves according the rule said by Watson.It is guaranteed that Holmes will select atleast 1 or 2 students
-----Constraints-----
- 1 ≤ T ≤ 10
- 1 ≤ N ≤ 10^5
- 1 ≤ Each of next N integers ≤ 10^9
-----Subtasks-----
Subtask #1 : (20 points)
- 1 ≤ T ≤ 10
- 1 ≤ N≤ 100
- 1 ≤ Each element≤ 10^3
Subtask 2 : (80 points)
- 1 ≤ T ≤ 10
- 1 ≤ N≤ 100000
- 1 ≤ Each element≤ 10^9
-----Example-----
Input:
2
5
2 3 5 1 2
3
1 2 3
Output:
3
3
-----Explanation-----
Example case 1. Here the first kid has 2 chocolates, second has 3 chocolates, third kid has 5 chocolates, which is the sum of first kid's total chocolates
and second kid's chocolate. Forth student has only 1 chocolate where he did not follow the rule. So the maximum number of kids who arranged themselves in the order was
3. That is students at index 1 to index 3.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
t = eval(input())
for i in range(t):
n = eval(input())
a = list(map(int, input().split()))
cnt = 2
cnt1 = 2
ll = len(a)
if ll < 3:
cnt1 = ll
else:
for j in range(2,ll):
if a[j-1] + a[j-2] == a[j]:
cnt += 1
cnt1 = max(cnt1, cnt)
else:
cnt1 = max(cnt1, cnt)
cnt = 2
print(cnt1)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Vision has finally made it to Wakanda to get his MindStone extracted. The MindStone was linked to his brain in a highly sophisticated manner and Shuri had to solve a complex problem to extract the stone. The MindStone had $n$ integers inscribed in it and Shuri needs to apply the prefix sum operation on the array $k$ times to extract the stone.
Formally, given $n$ integers $A[1], A[2] ..... A[n]$ and a number $k$, apply the operation
$A[i] = \sum_{j=1}^{i} A[j]$
on the array $k$ times.
Finally Shuri needs to apply $modulo$ $(10^9 + 7)$ operation to each element of the array. Can you help Shuri accomplish this task before Thanos gets to them?
-----Input:-----
- First line of the input consists of two space separated integers $n$ and $k$.
- Second line contains $n$ space separated integers $A[1] .. A[n]$.
-----Output:-----
In a single line print $n$ space separated integers, the values of the resultant array after applying all the operations.
-----Constraints-----
- $1 \leq n \leq 1000$
- $1 \leq k \leq 10^{12}$
- $1 \leq A[i] \leq 10^9$
-----Subtasks-----
- 20 Points: $1 \leq k \leq 1000$
- 30 Points: $1 \leq k \leq 1000000$
- 50 Points: Original Constraints
-----Sample Input:-----
$4$ $2$
$3$ $4$ $1$ $5$
-----Sample Output:-----
$3$ $10$ $18$ $31$
-----EXPLANATION:-----
After applying the prefix sum operation once the array becomes -> $3$ $7$ $8$ $13$
After applying the prefix sum operation for the second time, the array becomes -> $3$ $10$ $18$ $31$
After applying $modulo$ $(10^9 +7)$ operation, array becomes -> $3$ $10$ $18$ $31$
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 itertools import accumulate
n, k = map(int, input().split())
lst = list(map(int, input().split()))
temp = (10**9)+7
for i in range(k):
lst = list(accumulate(lst))
for i in lst:
print(i%(temp), end = ' ')
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
The chef has a number N, Cheffina challenges chef to form the largest number X from the digits of N.
-----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$.
-----Output:-----
For each test case, output in a single line answer.
-----Constraints-----
- $1 \leq T \leq 10^5$
- $1 \leq N \leq 10^6$
-----Sample Input:-----
2
2
212
-----Sample Output:-----
2
221
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())
l=[]
for i in range(n):
a=int(input())
l.append(a)
for i in l:
b = list(map(int, str(i)))
b.sort(reverse=True)
s = [str(i) for i in b]
r = int("".join(s))
print(r)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
You are given an unweighted, undirected graph. Write a program to check if it's a tree topology.
-----Input-----
The first line of the input file contains two integers N and M --- number of nodes and number of edges in the graph (0 < N <= 10000, 0 <= M <= 20000). Next M lines contain M edges of that graph --- Each line contains a pair (u, v) means there is an edge between node u and node v (1 <= u,v <= N).
-----Output-----
Print YES if the given graph is a tree, otherwise print NO.
-----Example-----
Input:
3 2
1 2
2 3
Output:
YES
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 python
def iscycle(E, v, EXPLORED_NODES, EXPLORED_EDGES):
EXPLORED_NODES.add(v)
r = False
for e in [x for x in E if v in x]:
if e in EXPLORED_EDGES: continue
if e[0] == v: w = e[1]
else: w = e[0]
if w in EXPLORED_NODES:
return True
else:
EXPLORED_EDGES.add(e)
r = r or iscycle(E, w, EXPLORED_NODES, EXPLORED_EDGES)
if r: break
return r
def process(E):
return iscycle(E, 1, set(), set()) and 'NO' or 'YES'
def main():
N, M = list(map(int, input().split()))
E = []
for m in range(M):
U, V = list(map(int, input().split()))
if U > V: U, V = V, U
E.append((U, V))
print(process(E))
main()
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Chef has just started Programming, he is in first year of Engineering. Chef is reading about Relational Operators.
Relational Operators are operators which check relatioship between two values. Given two numerical values A and B you need to help chef in finding the relationship between them that is,
- First one is greater than second or,
- First one is less than second or,
- First and second one are equal.
-----Input-----
First line contains an integer T, which denotes the number of testcases. Each of the T lines contain two integers A and B.
-----Output-----
For each line of input produce one line of output. This line contains any one of the relational operators
'<' , '>' , '='.
-----Constraints-----
- 1 ≤ T ≤ 10000
- 1 ≤ A, B ≤ 1000000001
-----Example-----
Input:
3
10 20
20 10
10 10
Output:
<
>
=
-----Explanation-----
Example case 1. In this example 1 as 10 is lesser than 20.
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())):
x, y= map(int, input().split())
if x<y:
print('<')
elif x>y:
print('>')
else:
print('=')
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
You are given three numbers $a$, $b$, $c$ . Write a program to determine the largest number that is less than or equal to $c$ and leaves a remainder $b$ when divided by $a$.
-----Input:-----
- First line will contain $T$, number of testcases. Then the testcases follow.
- Each testcase contains a single line of input, having three integers $a$, $b$, $c$.
-----Output:-----
- For each testcase, output in a single line the largest number less than or equal to $c$.
-----Constraints:-----
- $1 \leq T \leq 100000$
- $0 \leq b < a < c \leq$ $10$^18
-----Sample Input:-----
1
7 2 10
-----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
# cook your dish here
for t in range(int(input())):
a,b,c=map(int,input().split())
p=(c//a)*a+b
if p<=c:
print(p)
else:
print(((c//a)-1)*a+b)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
The only difference between easy and hard versions is constraints.
The BerTV channel every day broadcasts one episode of one of the $k$ TV shows. You know the schedule for the next $n$ days: a sequence of integers $a_1, a_2, \dots, a_n$ ($1 \le a_i \le k$), where $a_i$ is the show, the episode of which will be shown in $i$-th day.
The subscription to the show is bought for the entire show (i.e. for all its episodes), for each show the subscription is bought separately.
How many minimum subscriptions do you need to buy in order to have the opportunity to watch episodes of purchased shows $d$ ($1 \le d \le n$) days in a row? In other words, you want to buy the minimum number of TV shows so that there is some segment of $d$ consecutive days in which all episodes belong to the purchased shows.
-----Input-----
The first line contains an integer $t$ ($1 \le t \le 10000$) — the number of test cases in the input. Then $t$ test case descriptions follow.
The first line of each test case contains three integers $n, k$ and $d$ ($1 \le n \le 2\cdot10^5$, $1 \le k \le 10^6$, $1 \le d \le n$). The second line contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \le a_i \le k$), where $a_i$ is the show that is broadcasted on the $i$-th day.
It is guaranteed that the sum of the values of $n$ for all test cases in the input does not exceed $2\cdot10^5$.
-----Output-----
Print $t$ integers — the answers to the test cases in the input in the order they follow. The answer to a test case is the minimum number of TV shows for which you need to purchase a subscription so that you can watch episodes of the purchased TV shows on BerTV for $d$ consecutive days. Please note that it is permissible that you will be able to watch more than $d$ days in a row.
-----Example-----
Input
4
5 2 2
1 2 1 2 1
9 3 3
3 3 3 2 2 2 1 1 1
4 10 4
10 8 6 4
16 9 8
3 1 4 1 5 9 2 6 5 3 5 8 9 7 9 3
Output
2
1
4
5
-----Note-----
In the first test case to have an opportunity to watch shows for two consecutive days, you need to buy a subscription on show $1$ and on show $2$. So the answer is two.
In the second test case, you can buy a subscription to any show because for each show you can find a segment of three consecutive days, consisting only of episodes of this show.
In the third test case in the unique segment of four days, you have four different shows, so you need to buy a subscription to all these four shows.
In the fourth test case, you can buy subscriptions to shows $3,5,7,8,9$, and you will be able to watch shows for the last eight days.
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, d = list(map(int, input().split()))
a = list(map(int, input().split()))
s = {}
for q in range(d):
s[a[q]] = s.get(a[q], 0)+1
ans = len(s)
for q in range(d, n):
if s[a[q-d]] == 1:
del s[a[q-d]]
else:
s[a[q-d]] -= 1
s[a[q]] = s.get(a[q], 0)+1
ans = min(ans, len(s))
print(ans)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
If Give an integer N . Write a program to obtain the sum of the first and last digits of this number.
-----Input-----
The first line contains an integer T, the total number of test cases. Then follow T lines, each line contains an integer N.
-----Output-----
For each test case, display the sum of first and last digits of N in a new line.
-----Constraints-----
- 1 ≤ T ≤ 1000
- 1 ≤ N ≤ 1000000
-----Example-----
Input
3
1234
124894
242323
Output
5
5
5
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())
for i in range(n):
s = input()
l = len(s)
n1 = int(s[0])
n2 = int(s[l-1])
print(n1+n2)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Sig has built his own keyboard. Designed for ultimate simplicity, this keyboard only has 3 keys on it: the 0 key, the 1 key and the backspace key.
To begin with, he is using a plain text editor with this keyboard. This editor always displays one string (possibly empty). Just after the editor is launched, this string is empty. When each key on the keyboard is pressed, the following changes occur to the string:
- The 0 key: a letter 0 will be inserted to the right of the string.
- The 1 key: a letter 1 will be inserted to the right of the string.
- The backspace key: if the string is empty, nothing happens. Otherwise, the rightmost letter of the string is deleted.
Sig has launched the editor, and pressed these keys N times in total. As a result, the editor displays a string s. Find the number of such ways to press the keys, modulo 10^9 + 7.
-----Constraints-----
- 1 ≦ N ≦ 5000
- 1 ≦ |s| ≦ N
- s consists of the letters 0 and 1.
-----Partial Score-----
- 400 points will be awarded for passing the test set satisfying 1 ≦ N ≦ 300.
-----Input-----
The input is given from Standard Input in the following format:
N
s
-----Output-----
Print the number of the ways to press the keys N times in total such that the editor displays the string s in the end, modulo 10^9+7.
-----Sample Input-----
3
0
-----Sample Output-----
5
We will denote the backspace key by B. The following 5 ways to press the keys will cause the editor to display the string 0 in the end: 00B, 01B, 0B0, 1B0, BB0. In the last way, nothing will happen when the backspace key is pressed.
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())
M=len(input())
O=10**9+7
D=[pow(-~O//2,M,O)]+[0]*N
for _ in'_'*N:D=[D[0]+D[1]]+[(i+2*j)%O for i,j in zip(D[2:]+[0],D[:-1])]
print(D[M])
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
-----Problem Statement-----
Levy's conjecture, named after Hyman Levy, states that all odd integers greater than 5 can be represented as the sum of an odd prime number and an even semiprime. To put it algebraically, 2n + 1 = p + 2q always has a solution in primes p and q (not necessary to be distinct) for n > 2. (Source: Wikipedia)
In this problem, given a positive integer N (not necessary to be odd integer greater than 5). Your task is to calculate how many distinct ordered pairs (p, q) such that N = p + 2q, where p and q are primes.
-----Input-----
The first line of input contains an integer T, denoting the number of test cases. Then T test cases follow.
Each test case consists of exactly one line containing an integer N.
-----Constraints-----
- 1 ≤ T ≤ 100000 (105)
- 1 ≤ N ≤ 10000 (104)
-----Output-----
For each test case, output the number of ordered pairs (p, q) of primes such that N = p + 2q.
-----Example-----
Input:
3
2
7
11
Output:
0
1
2
-----Explanation-----
Case #1: There are no ordered pairs (p, q) such that p + 2q = 2.
Case #2: There is only one ordered pair (p, q) = (3, 2) such that p + 2q = 7.
Case #3: There are two ordered pairs (p, q) = (7, 2), (5, 3) such that p + 2q = 11.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
isPrime=[1 for i in range(10001)]
cnt=[0 for i in range(10001)]
isPrime[0]=0
isPrime[1]=0
prime=[]
for i in range(2,10001):
if isPrime[i]:
prime.append(i)
for j in range(i*i,10001,i):
isPrime[j]=0
#print(prime)
for i in prime:
for j in prime:
if (i + 2*j)>10000:
break
else:
cnt[i + 2*j]+=1
#print(le)
for _ in range(int(input())):
n=int(input())
print(cnt[n])
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Vivek initially has an empty array $a$ and some integer constant $m$.
He performs the following algorithm: Select a random integer $x$ uniformly in range from $1$ to $m$ and append it to the end of $a$. Compute the greatest common divisor of integers in $a$. In case it equals to $1$, break Otherwise, return to step $1$.
Find the expected length of $a$. It can be shown that it can be represented as $\frac{P}{Q}$ where $P$ and $Q$ are coprime integers and $Q\neq 0 \pmod{10^9+7}$. Print the value of $P \cdot Q^{-1} \pmod{10^9+7}$.
-----Input-----
The first and only line contains a single integer $m$ ($1 \leq m \leq 100000$).
-----Output-----
Print a single integer — the expected length of the array $a$ written as $P \cdot Q^{-1} \pmod{10^9+7}$.
-----Examples-----
Input
1
Output
1
Input
2
Output
2
Input
4
Output
333333338
-----Note-----
In the first example, since Vivek can choose only integers from $1$ to $1$, he will have $a=[1]$ after the first append operation, and after that quit the algorithm. Hence the length of $a$ is always $1$, so its expected value is $1$ as well.
In the second example, Vivek each time will append either $1$ or $2$, so after finishing the algorithm he will end up having some number of $2$'s (possibly zero), and a single $1$ in the end. The expected length of the list is $1\cdot \frac{1}{2} + 2\cdot \frac{1}{2^2} + 3\cdot \frac{1}{2^3} + \ldots = 2$.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
big = 100010
def gen_mu():
mu = [1]*big
mu[0] = 0
P = [True]*big
P[0] = P[1] = False
for i in range(2,big):
if P[i]:
j = i
while j<big:
P[j] = False
mu[j] *= -1
j += i
j = i*i
while j<big:
mu[j] = 0
j += i*i
return mu
m = int(input())
mu = gen_mu()
MOD = 10**9+7
def mod_inv(x):
return pow(x, MOD-2, MOD)
s = 1
for i in range(2,big):
# p is probabilty that i | a random number [1,m]
p = (m//i)*mod_inv(m)
s += (-mu[i])*(p)*mod_inv(1-p)
print(s%MOD)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
You are given an array $a$ of length $2n$. Consider a partition of array $a$ into two subsequences $p$ and $q$ of length $n$ each (each element of array $a$ should be in exactly one subsequence: either in $p$ or in $q$).
Let's sort $p$ in non-decreasing order, and $q$ in non-increasing order, we can denote the sorted versions by $x$ and $y$, respectively. Then the cost of a partition is defined as $f(p, q) = \sum_{i = 1}^n |x_i - y_i|$.
Find the sum of $f(p, q)$ over all correct partitions of array $a$. Since the answer might be too big, print its remainder modulo $998244353$.
-----Input-----
The first line contains a single integer $n$ ($1 \leq n \leq 150\,000$).
The second line contains $2n$ integers $a_1, a_2, \ldots, a_{2n}$ ($1 \leq a_i \leq 10^9$) — elements of array $a$.
-----Output-----
Print one integer — the answer to the problem, modulo $998244353$.
-----Examples-----
Input
1
1 4
Output
6
Input
2
2 1 2 1
Output
12
Input
3
2 2 2 2 2 2
Output
0
Input
5
13 8 35 94 9284 34 54 69 123 846
Output
2588544
-----Note-----
Two partitions of an array are considered different if the sets of indices of elements included in the subsequence $p$ are different.
In the first example, there are two correct partitions of the array $a$: $p = [1]$, $q = [4]$, then $x = [1]$, $y = [4]$, $f(p, q) = |1 - 4| = 3$; $p = [4]$, $q = [1]$, then $x = [4]$, $y = [1]$, $f(p, q) = |4 - 1| = 3$.
In the second example, there are six valid partitions of the array $a$: $p = [2, 1]$, $q = [2, 1]$ (elements with indices $1$ and $2$ in the original array are selected in the subsequence $p$); $p = [2, 2]$, $q = [1, 1]$; $p = [2, 1]$, $q = [1, 2]$ (elements with indices $1$ and $4$ are selected in the subsequence $p$); $p = [1, 2]$, $q = [2, 1]$; $p = [1, 1]$, $q = [2, 2]$; $p = [2, 1]$, $q = [2, 1]$ (elements with indices $3$ and $4$ are selected in the subsequence $p$).
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
import sys
from sys import stdin
def modfac(n, MOD):
f = 1
factorials = [1]
for m in range(1, n + 1):
f *= m
f %= MOD
factorials.append(f)
inv = pow(f, MOD - 2, MOD)
invs = [1] * (n + 1)
invs[n] = inv
for m in range(n, 1, -1):
inv *= m
inv %= MOD
invs[m - 1] = inv
return factorials, invs
def modnCr(n,r,mod,fac,inv):
return fac[n] * inv[n-r] * inv[r] % mod
mod = 998244353
n = int(stdin.readline())
a = list(map(int,stdin.readline().split()))
a.sort()
fac,inv = modfac(2*n+10,mod)
print( (modnCr(2*n,n,mod,fac,inv) * (sum(a[n:]) - sum(a[:n]))) % mod )
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Есть n-подъездный дом, в каждом подъезде по m этажей, и на каждом этаже каждого подъезда ровно k квартир. Таким образом, в доме всего n·m·k квартир. Они пронумерованы естественным образом от 1 до n·m·k, то есть первая квартира на первом этаже в первом подъезде имеет номер 1, первая квартира на втором этаже первого подъезда имеет номер k + 1 и так далее. Особенность этого дома состоит в том, что он круглый. То есть если обходить его по часовой стрелке, то после подъезда номер 1 следует подъезд номер 2, затем подъезд номер 3 и так далее до подъезда номер n. После подъезда номер n снова идёт подъезд номер 1.
Эдвард живёт в квартире номер a, а Наташа — в квартире номер b. Переход на 1 этаж вверх или вниз по лестнице занимает 5 секунд, переход от двери подъезда к двери соседнего подъезда — 15 секунд, а переход в пределах одного этажа одного подъезда происходит мгновенно. Также в каждом подъезде дома есть лифт. Он устроен следующим образом: он всегда приезжает ровно через 10 секунд после вызова, а чтобы переместить пассажира на один этаж вверх или вниз, лифт тратит ровно 1 секунду. Посадка и высадка происходят мгновенно.
Помогите Эдварду найти минимальное время, за которое он сможет добраться до квартиры Наташи. Считайте, что Эдвард может выйти из подъезда только с первого этажа соответствующего подъезда (это происходит мгновенно). Если Эдвард стоит перед дверью какого-то подъезда, он может зайти в него и сразу окажется на первом этаже этого подъезда (это также происходит мгновенно). Эдвард может выбирать, в каком направлении идти вокруг дома.
-----Входные данные-----
В первой строке входных данных следуют три числа n, m, k (1 ≤ n, m, k ≤ 1000) — количество подъездов в доме, количество этажей в каждом подъезде и количество квартир на каждом этаже каждого подъезда соответственно.
Во второй строке входных данных записаны два числа a и b (1 ≤ a, b ≤ n·m·k) — номера квартир, в которых живут Эдвард и Наташа, соответственно. Гарантируется, что эти номера различны.
-----Выходные данные-----
Выведите единственное целое число — минимальное время (в секундах), за которое Эдвард сможет добраться от своей квартиры до квартиры Наташи.
-----Примеры-----
Входные данные
4 10 5
200 6
Выходные данные
39
Входные данные
3 1 5
7 2
Выходные данные
15
-----Примечание-----
В первом тестовом примере Эдвард находится в 4 подъезде на 10 этаже, а Наташа находится в 1 подъезде на 2 этаже. Поэтому Эдварду выгодно сначала спуститься на лифте на первый этаж (на это он потратит 19 секунд, из которых 10 — на ожидание и 9 — на поездку на лифте), затем обойти дом против часовой стрелки до подъезда номер 1 (на это он потратит 15 секунд), и наконец подняться по лестнице на этаж номер 2 (на это он потратит 5 секунд). Таким образом, ответ равен 19 + 15 + 5 = 39.
Во втором тестовом примере Эдвард живёт в подъезде 2 на этаже 1, а Наташа находится в подъезде 1 на этаже 1. Поэтому Эдварду выгодно просто обойти дом по часовой стрелке до подъезда 1, на это он потратит 15 секунд.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
n, m, k = map(int, input().split())
a, b = map(int, input().split())
a -= 1
b -= 1
def p(x):
return x // (m * k)
def e(x):
return (x - p(x) * m * k) // k
def lift(x):
return min(5 * x, 10 + x)
if p(a) == p(b):
dif = abs(e(a) - e(b))
print(lift(dif))
else:
print(lift(e(a)) + 15 * min((p(a) - p(b) + n) % n, (p(b) - p(a) + n) % n) + lift(e(b)))
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Chef has $N$ small boxes arranged on a line from $1$ to $N$. For each valid $i$, the weight of the $i$-th box is $W_i$. Chef wants to bring them to his home, which is at the position $0$. He can hold any number of boxes at the same time; however, the total weight of the boxes he's holding must not exceed K at any time, and he can only pick the ith box if all the boxes between Chef's home and the ith box have been either moved or picked up in this trip.
Therefore, Chef will pick up boxes and carry them home in one or more round trips. Find the smallest number of round trips he needs or determine that he cannot bring all boxes home.
-----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 $N$ space-separated integers $W_1, W_2, \ldots, W_N$.
-----Output-----
For each test case, print a single line containing one integer ― the smallest number of round trips or $-1$ if it is impossible for Chef to bring all boxes home.
-----Constraints-----
- $1 \le T \le 100$
- $1 \le N, K \le 10^3$
- $1 \le W_i \le 10^3$ for each valid $i$
-----Example Input-----
4
1 1
2
2 4
1 1
3 6
3 4 2
3 6
3 4 3
-----Example Output-----
-1
1
2
3
-----Explanation-----
Example case 1: Since the weight of the box higher than $K$, Chef can not carry that box home in any number of the round trip.
Example case 2: Since the sum of weights of both boxes is less than $K$, Chef can carry them home in one round trip.
Example case 3: In the first round trip, Chef can only pick up the box at position $1$. In the second round trip, he can pick up both remaining boxes at positions $2$ and $3$.
Example case 4: Chef can only carry one box at a time, so three round trips are required.
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):
x,y=0,0
n,m=list(map(int,input().split()))
l=list(map(int,input().split()))
if(max(l)>m):
print(-1)
else:
for i in range(len(l)):
y+=l[i]
if(y>m):
y=l[i]
x+=1
if(y>0):
x+=1
print(x)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
You are given $n$ arrays that can have different sizes. You also have a table with $w$ columns and $n$ rows. The $i$-th array is placed horizontally in the $i$-th row. You can slide each array within its row as long as it occupies several consecutive cells and lies completely inside the table.
You need to find the maximum sum of the integers in the $j$-th column for each $j$ from $1$ to $w$ independently.
[Image] Optimal placements for columns $1$, $2$ and $3$ are shown on the pictures from left to right.
Note that you can exclude any array out of a column provided it remains in the window. In this case its value is considered to be zero.
-----Input-----
The first line contains two integers $n$ ($1 \le n \le 10^{6}$) and $w$ ($1 \le w \le 10^{6}$) — the number of arrays and the width of the table.
Each of the next $n$ lines consists of an integer $l_{i}$ ($1 \le l_{i} \le w$), the length of the $i$-th array, followed by $l_{i}$ integers $a_{i1}, a_{i2}, \ldots, a_{il_i}$ ($-10^{9} \le a_{ij} \le 10^{9}$) — the elements of the array.
The total length of the arrays does no exceed $10^{6}$.
-----Output-----
Print $w$ integers, the $i$-th of them should be the maximum sum for column $i$.
-----Examples-----
Input
3 3
3 2 4 8
2 2 5
2 6 3
Output
10 15 16
Input
2 2
2 7 8
1 -8
Output
7 8
-----Note-----
Illustration for the first example is in the statement.
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
from collections import deque
def slidemax(X, k):
q = deque([])
ret = []
for i in range(len(X)):
while q and q[-1][1] <= X[i]:
q.pop()
deque.append(q, (i+k, X[i]))
if q[0][0] == i:
deque.popleft(q)
if i >= k-1:
ret.append(q[0][1])
return ret
N, W = list(map(int, input().split()))
A = [0] * W
s = 0
for _ in range(N):
l, *B = list(map(int, input().split()))
if l*2 < W:
C = slidemax([0]*(l-1)+B+[0]*(l-1), l)
m = max(B + [0])
s += m
for i in range(l-1):
A[i] += C[i] - m
A[-i-1] += C[-i-1] - m
else:
C = slidemax([0]*(W-l)+B+[0]*(W-l), W - l + 1)
A = [a+c for a, c in zip(A, C)]
print(*[a+s for a in A])
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
The auditorium of Stanford University is made up of L*R matrix (assume each coordinate has a chair). On the occasion of an event Chef was called as a chief guest. The auditorium was filled with males (M) and females (F), occupying one chair each. Our Chef is very curious guy, so he asks the gatekeeper some queries. The queries were as follows: Is there any K*K sub-matrix in the auditorium which contains all Males or Females.
-----Input-----
- The first line contains three space-separated integers L, R and Q describing the dimension of the auditorium and the number of questions Chef will ask.
- Each of next L lines contains R characters (M or F).
- Next Q lines contains K and a character (M or F).
-----Output-----
- For each query output "yes" (without quotes) if there exist any K*K sub-matrix in the auditorium which contains all Males (if he asks about Male) or Females (if he asks about Female), otherwise output "no" (without quotes).
-----Constraints and Subtasks-----
- 1 <= L, R, K <= 1000
- 1 <= Q <= 1e6
Subtask 1: 30 points
- 1 <= L, R, Q <= 200
Subtask 2: 70 points
- Original Contraints
-----Example-----
Input:
4 3 3
MMF
MMM
FFM
FFM
2 F
3 M
1 M
Output:
yes
no
yes
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
def matrix(L,row,col,c):
d={}
dp=[]
for i in range(row+1):
temp=[]
for i in range(col+1):
temp.append([])
dp.append(temp)
for i in range(row+1):
dp[i][0]=0
for i in range(col+1):
dp[0][i]=0
for i in range(1,row+1):
for j in range(1,col+1):
if L[i-1][j-1]==c:
dp[i][j]=min(dp[i][j-1],dp[i-1][j],dp[i-1][j-1])+1
else:
dp[i][j]=0
d[dp[i][j]]=d.get(dp[i][j],0)+1
## for i in xrange(row+1):
## for j in xrange(col+1):
## print dp[i][j],
## print
return d
from sys import stdin
n,m,q=list(map(int,stdin.readline().split()))
L=[]
for i in range(n):
L.append(stdin.readline().strip())
male=matrix(L,n,m,'M')
female=matrix(L,n,m,'F')
for i in range(q):
query=stdin.readline().split()
if query[1]=='F':
if female.get(int(query[0]),0)==0:
print('no')
else:
print('yes')
else:
if male.get(int(query[0]),0)==0:
print('no')
else:
print('yes')
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
The chef is playing a game of long distance. Chef has a number K and he wants to find the longest distance between the index of the first and the last occurrence of K in a given array of N numbers.
-----Input:-----
- First-line will contain $T$, the number of test cases. Then the test cases follow.
- Each test case contains two lines of input.
- Next line with Two integers in one line $K, N$.
- Next line with $N$ space-separated integers.
-----Output:-----
For each test case, output in a single line answer as the index of first and last occurrence of K in the given array.
Note: Here Indexing is from 1 not 0 based.
-----Constraints-----
- $1 \leq T \leq 100$
- $1 \leq k \leq 10^5$
- $1 \leq N \leq 10^5$
-----Sample Input:-----
2
2 6
2 3 4 2 1 6
4 6
2 3 4 2 1 6
-----Sample Output:-----
3
0
-----EXPLANATION:-----
For 1) Index of First and last occurrence of 2 in the given array is at 1 and 4, i.e. distance is 3.
For 2) 4 occurs only once in the given array hence print 0.
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())):
m,n=list(map(int,input().split()))
a=[int(i) for i in input().split()]
l=-1
for i in range(n-1,-1,-1):
if a[i]==m:
l=i
break
f=-1
for i in range(0,n):
if a[i]==m:
f=i
break
print(l-f)
``` |
|
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 50$
- $1 \leq K \leq 50$
-----Sample Input:-----
5
1
2
3
4
5
-----Sample Output:-----
*
*
***
*
* *
*****
*
* *
* *
*******
*
* *
* *
* *
*********
-----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
from sys import stdin, stdout
from collections import Counter
n = int(stdin.readline())
#l = list(map(int, stdin.readline().split()))
#l = [int(stdin.readline()) for _ in range(n)]
#a, b = map(int, stdin.readline().split())
for _ in range(n):
n1 = int(stdin.readline())
if n1==1:
print('*')
else:
a = n1+(n1-1)
s = 0
for x in range(1,n1):
if x==1:
print(' '*(n1-1)+'*'+' '*(n1-1))
s+=1
else:
print(' '*(n1-x)+'*'+' '*(s)+'*')
s+=2
#print()
print('*'*(a))
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
-----Problem Statement-----
You all must have played the game candy crush. So here is a bomb which works much the fruit bomb in candy crush. A designer, Anton, designed a very powerful bomb. The bomb, when placed on a location $(x, y)$ in a $R \times C$ grid, wipes out the row $x$ and column $y$ completely.
You are given a $R\times C$ grid with $N$ targets. You have only one bomb. Your aim is to maximize the damage and hence destroy most number of targets. Given the location of targets on the grid, find out the number of targets that can destroyed.
The grid system uses index starting with $0$.
-----Input-----
- First line contains three space separated integers, $R$, $C$ and $N$. Then, $N$ lines follow.
- Each line contains space separated integers $r$ and $c$ mentioning the location of the target.
-----Output-----
A single integer giving the number of targets that can be destroyed.
-----Constraints-----
- $1 \leq R, C \leq 3 \times 10^5$
- $1 \leq N \leq min(R \times C, 3 \times 10^5)$
- $0 \leq r < R$
- $0 \leq c < C$
- Any input pair $(r, c)$ is not repeated.
-----Subtasks-----
The total marks will be divided into:
- 20% : $R, C \leq 10^3$
- 80% : Original Constraints
-----Sample Input-----
2 3 3
1 1
0 0
0 2
-----Sample Output-----
3
-----EXPLANATION-----
It is possible to destroy all the targets if we place the bomb at $(0, 1)$. Hence, total number of targets destroyed is $3$, which is our answer.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
r,c,n = map(int , input().split());coordinates = [];coordinates_1,coordinates_2 = {},{}
for _ in range(n):
x,y = map(int , input().split())
coordinates.append([x,y])
for i in coordinates:
if(i[0] in coordinates_1): coordinates_1[i[0]] += 1
else: coordinates_1[i[0]] = 1
if(i[1] in coordinates_2): coordinates_2[i[1]] += 1
else: coordinates_2[i[1]] = 1
print(max(coordinates_1.values()) + max(coordinates_2.values()))
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Young Sheldon is given the task to teach Chemistry to his brother Georgie. After teaching him how to find total atomic weight, Sheldon gives him some formulas which consist of $x$, $y$ and $z$ atoms as an assignment.
You already know that Georgie doesn't like Chemistry, so he want you to help him solve this assignment.
Let the chemical formula be given by the string $S$. It consists of any combination of x, y and z with some value associated with it as well as parenthesis to encapsulate any combination. Moreover, the atomic weight of x, y and z are 2, 4 and 10 respectively.
You are supposed to find the total atomic weight of the element represented by the given formula.
For example, for the formula $(x_2y_2)_3z$, given string $S$ will be: $(x2y2)3z$. Hence, substituting values of x, y and z, total atomic weight will be
$(2*2+4*2)*3 + 10 = 46$.
-----Input:-----
- First line will contain $T$, number of testcases. Then the testcases follow.
- Each testcase contains of a single line of input $S$.
-----Output:-----
For each testcase, output in a single line, the total atomic weight.
-----Constraints-----
- $1 \leq T \leq 100$
- Length of string $S \leq 100$
- String contains $x, y, z, 1, 2,..., 9$ and parenthesis
-----Sample Input:-----
2
(xy)2
x(x2y)3(z)2
-----Sample Output:-----
12
46
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 = list(input().strip())
i = 0
while i < len(s) - 1:
if s[i].isalpha() or s[i] == ')':
if s[i + 1].isdigit():
if i + 2 >= len(s) or s[i + 2] == ')':
s = s[:i+1] + ['*', s[i+1]] + s[i+2:]
else:
s = s[:i+1] + ['*', s[i+1], '+'] + s[i+2:]
i += 1
elif s[i + 1].isalpha() or s[i + 1] == '(':
s = s[:i+1] + ['+'] + s[i+1:]
i += 1
s = ''.join(s)
s = s.strip('+')
x = 2
y = 4
z = 10
print(eval(s))
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
As you might remember, the collector of Siruseri had ordered
a complete revision of the Voters List. He knew that constructing
the list of voters is a difficult task, prone to errors. Some
voters may have been away on vacation, others may have moved
during the enrollment and so on.
To be as accurate as possible, he entrusted the task to three different
officials. Each of them was to independently record the list of voters and
send it to the collector. In Siruseri, every one has a ID number and
the list would only list the ID numbers of the voters and not their names.
The officials were expected to arrange the ID numbers in ascending order
in their lists.
On receiving the lists, the Collector realised that there were
discrepancies - the three lists were not identical. He decided
to go with the majority. That is, he decided to construct the
final list including only those ID numbers that appeared in at
least 2 out of the 3 lists. For example if the three lists
were
23 30 42 57 90
21 23 35 57 90 92
21 23 30 57 90
then the final list compiled by the collector would be:
21 23 30 57 90
The ID numbers 35, 42 and 92 which appeared in only one list
each do not figure in the final list.
Your task is to help the collector by writing a program that
produces the final list from the three given lists.
Input format
The first line of the input contains 3 integers
N1, N2 and
N3. N1 is the number of
voters in the first list, N2 is the number of
voters in the second list and N3 is the number of
voters in the third list. The next N1 lines
(lines 2,...,N1+1) contain one positive integer
each and describe the first list in ascending order. The following
N2 lines (lines
N1+2,...,N1+N2+1)
describe the second list in ascending order and the final
N3 lines (lines
N1+N2+2,...,N1+N2+N3+1)
describe the third list in ascending order.
Output format
The first line of the output should contain a single integer
M indicating the number voters in the final list. The next
M lines (lines 2,...,M+1) should contain one
positive integer each, describing the list of voters in the final
list, in ascending order.
Test data
You may assume that 1 ≤
N1,N2,N3
≤ 50000. You may also assume that in 50% of the inputs 1 ≤ N1,N2,N3 ≤ 2000.
Example
Sample input:
5 6 5
23
30
42
57
90
21
23
35
57
90
92
21
23
30
57
90
Sample output:
5
21
23
30
57
90
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 stdout, stdin
n,m,o = list(map(int, stdin.readline().split()))
n= n+m+o
l=[]
a=[]
for i in range(n):
b= int(stdin.readline())
if(b in l and b not in a):
l.append(b)
a.append(b)
elif(b not in l):
l.append(b)
a.sort()
stdout.write(str(len(a)) + '\n')
stdout.write(''.join([str(id) + '\n' for id in a]))
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Chef usually likes to play cricket, but now, he is bored of playing it too much, so he is trying new games with strings. Chef's friend Dustin gave him binary strings $S$ and $R$, each with length $N$, and told him to make them identical. However, unlike Dustin, Chef does not have any superpower and Dustin lets Chef perform only operations of one type: choose any pair of integers $(i, j)$ such that $1 \le i, j \le N$ and swap the $i$-th and $j$-th character of $S$. He may perform any number of operations (including zero).
For Chef, this is much harder than cricket and he is asking for your help. Tell him whether it is possible to change the string $S$ to the target string $R$ only using operations of the given type.
-----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 a binary string $S$.
- The third line contains a binary string $R$.
-----Output-----
For each test case, print a single line containing the string "YES" if it is possible to change $S$ to $R$ or "NO" if it is impossible (without quotes).
-----Constraints-----
- $1 \le T \le 400$
- $1 \le N \le 100$
- $|S| = |R| = N$
- $S$ and $R$ will consist of only '1' and '0'
-----Example Input-----
2
5
11000
01001
3
110
001
-----Example Output-----
YES
NO
-----Explanation-----
Example case 1: Chef can perform one operation with $(i, j) = (1, 5)$. Then, $S$ will be "01001", which is equal to $R$.
Example case 2: There is no sequence of operations which would make $S$ equal to $R$.
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())):
length = int(input())
S = input()
R = input()
if S.count("1") == R.count("1"):
print("YES")
else:
print("NO")
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
A string with length $L$ is called rich if $L \ge 3$ and there is a character which occurs in this string strictly more than $L/2$ times.
You are given a string $S$ and you should answer $Q$ queries on this string. In each query, you are given a substring $S_L, S_{L+1}, \ldots, S_R$. Consider all substrings of this substring. You have to determine whether at least one of them is rich.
-----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 $Q$.
- The second line contains a single string $S$ with length $N$.
- Each of the next $Q$ lines contains two space-separated integers $L$ and $R$ describing a query.
-----Output-----
For each query, print a single line containing the string "YES" if the given substring contains a rich substring or "NO" if it does not contain any rich substring.
-----Constraints-----
- $1 \le T \le 10$
- $1 \le N, Q \le 10^5$
- $1 \le L \le R \le N$
- $S$ contains only lowercase English letters
-----Example Input-----
1
10 2
helloworld
1 3
1 10
-----Example Output-----
NO
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 _ in range(t):
n,q=map(int,input().split())
s=input()
l=[0]*(n-1)
for i in range(n-2):
a,b,c=s[i],s[i+1],s[i+2]
if len(set([a,b,c]))<3:
l[i]=l[i-1]+1
else:
l[i]=l[i-1]
for i in range(q):
left,right=map(int,input().split())
left-=1
right-=1
if right-left+1 <3:
print('NO')
continue
if (l[right-2]-l[left-1])>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 an array $a$ consisting of $n$ integers. Beauty of array is the maximum sum of some consecutive subarray of this array (this subarray may be empty). For example, the beauty of the array [10, -5, 10, -4, 1] is 15, and the beauty of the array [-3, -5, -1] is 0.
You may choose at most one consecutive subarray of $a$ and multiply all values contained in this subarray by $x$. You want to maximize the beauty of array after applying at most one such operation.
-----Input-----
The first line contains two integers $n$ and $x$ ($1 \le n \le 3 \cdot 10^5, -100 \le x \le 100$) — the length of array $a$ and the integer $x$ respectively.
The second line contains $n$ integers $a_1, a_2, \dots, a_n$ ($-10^9 \le a_i \le 10^9$) — the array $a$.
-----Output-----
Print one integer — the maximum possible beauty of array $a$ after multiplying all values belonging to some consecutive subarray $x$.
-----Examples-----
Input
5 -2
-3 8 -2 1 -6
Output
22
Input
12 -3
1 3 3 7 1 3 3 7 1 3 3 7
Output
42
Input
5 10
-1 -2 -3 -4 -5
Output
0
-----Note-----
In the first test case we need to multiply the subarray [-2, 1, -6], and the array becomes [-3, 8, 4, -2, 12] with beauty 22 ([-3, 8, 4, -2, 12]).
In the second test case we don't need to multiply any subarray at all.
In the third test case no matter which subarray we multiply, the beauty of array will be 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
N, X = list(map(int, input().split()))
A = [int(a) for a in input().split()]
dp = [[0]*4 for _ in range(N+1)]
for i in range(1, N+1):
dp[i][0] = max(dp[i-1][0] + A[i-1], 0)
dp[i][1] = max(dp[i-1][1] + A[i-1] * X, dp[i][0])
dp[i][2] = max(dp[i-1][2] + A[i-1], dp[i][1])
dp[i][3] = max(dp[i-1][3], dp[i][2])
print(dp[N][3])
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
A prime number is number x which has only divisors as 1 and x itself.
Harsh is playing a game with his friends, where his friends give him a few numbers claiming that they are divisors of some number x but divisor 1 and the number x itself are not being given as divisors.
You need to help harsh find which number's divisors are given here.
His friends can also give him wrong set of divisors as a trick question for which no number exists.
Simply, We are given the divisors of a number x ( divisors except 1 and x itself ) , you have to print the number if only it is possible.
You have to answer t queries.
(USE LONG LONG TO PREVENT OVERFLOW)
-----Input:-----
- First line is T queires.
- Next are T queries.
- First line is N ( No of divisors except 1 and the number itself )
- Next line has N integers or basically the divisors.
-----Output:-----
Print the minimum possible x which has such divisors and print -1 if not possible.
-----Constraints-----
- 1<= T <= 30
- 1<= N <= 350
- 2<= Di <=10^6
-----Sample Input:-----
3
2
2 3
2
4 2
3
12 3 2
-----Sample Output:-----
6
8
-1
-----EXPLANATION:-----
Query 1 : Divisors of 6 are ( 1,2,3,6) Therefore, Divisors except 1 and the number 6 itself are ( 2 , 3). Thus, ans = 6.
Query 2 : Divisors of 8 are ( 1,2,4,8) Therefore, Divisors except 1 and the number 8 itself are ( 2 , 4). Thus, ans = 8.
Query 3 : There is no such number x with only ( 1,2,3,12,x ) as the divisors.
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 findnumber(l,n):
l.sort()
x = l[0] * l[-1]
vec = []
i = 2
while (i*i)<=x:
if x%i==0:
vec.append(i)
if x//i !=i:
vec.append(x//i)
i = i + 1
vec.sort()
if len(vec)!=n:
return -1
else:
j = 0
for it in range(n):
if(l[j] != vec[it]):
return -1
else:
j += 1
return x
def __starting_point():
t = int(input())
while t:
n = int(input())
arr = list(map(int,input().split()))
n = len(arr)
print(findnumber(arr,n))
print()
t=t-1
__starting_point()
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
There is a country with $n$ citizens. The $i$-th of them initially has $a_{i}$ money. The government strictly controls the wealth of its citizens. Whenever a citizen makes a purchase or earns some money, they must send a receipt to the social services mentioning the amount of money they currently have.
Sometimes the government makes payouts to the poor: all citizens who have strictly less money than $x$ are paid accordingly so that after the payout they have exactly $x$ money. In this case the citizens don't send a receipt.
You know the initial wealth of every citizen and the log of all events: receipts and payouts. Restore the amount of money each citizen has after all events.
-----Input-----
The first line contains a single integer $n$ ($1 \le n \le 2 \cdot 10^{5}$) — the numer of citizens.
The next line contains $n$ integers $a_1$, $a_2$, ..., $a_n$ ($0 \le a_{i} \le 10^{9}$) — the initial balances of citizens.
The next line contains a single integer $q$ ($1 \le q \le 2 \cdot 10^{5}$) — the number of events.
Each of the next $q$ lines contains a single event. The events are given in chronological order.
Each event is described as either 1 p x ($1 \le p \le n$, $0 \le x \le 10^{9}$), or 2 x ($0 \le x \le 10^{9}$). In the first case we have a receipt that the balance of the $p$-th person becomes equal to $x$. In the second case we have a payoff with parameter $x$.
-----Output-----
Print $n$ integers — the balances of all citizens after all events.
-----Examples-----
Input
4
1 2 3 4
3
2 3
1 2 2
2 1
Output
3 2 3 4
Input
5
3 50 2 1 10
3
1 2 0
2 8
1 3 20
Output
8 8 20 8 10
-----Note-----
In the first example the balances change as follows: 1 2 3 4 $\rightarrow$ 3 3 3 4 $\rightarrow$ 3 2 3 4 $\rightarrow$ 3 2 3 4
In the second example the balances change as follows: 3 50 2 1 10 $\rightarrow$ 3 0 2 1 10 $\rightarrow$ 8 8 8 8 10 $\rightarrow$ 8 8 20 8 10
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=list(map(int,input().split()))
q=int(input())
changes=[0]*q
for i in range(q):
changes[-i-1]=tuple(map(int,input().split()))
final=[-1]*n
curr=0
for guy in changes:
if guy[0]==1:
if final[guy[1]-1]==-1:
final[guy[1]-1]=max(guy[2],curr)
else:
curr=max(curr,guy[1])
for i in range(n):
if final[i]==-1:
final[i]=max(curr,a[i])
final=[str(guy) for guy in final]
print(" ".join(final))
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Chef has a garden with $N$ plants arranged in a line in decreasing order of height. Initially the height of the plants are $A_1, A_2, ..., A_N$.
The plants are growing, after each hour the height of the $i$-th plant increases by $i$ millimeters. Find the minimum number of integer hours that Chef must wait to have two plants of the same height.
-----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,..A_N$.
-----Output:-----
For each test case print a single line containing one integer, the minimum number of integer hours that Chef must wait to have two plants of the same height.
-----Constraints-----
- $1 \leq T \leq 1000$
- $2 \leq N \leq 10^5$
- $0\leq A_i \leq 10^{18}$
- $A_i >A_{i+1}$, for each valid $i$
- The Sum of $N$ over all test cases does not exceed $10^6$
-----Sample Input:-----
1
3
8 4 2
-----Sample Output:-----
2
-----EXPLANATION:-----
After $2$ hours there are two plants with the same height.
$[8,4,2] \rightarrow [9,6,5] \rightarrow [10,8,8]$.
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 = int(input())
arr = list(map(int, input().split()))
hrs = arr[0] - arr[1]
for i in range(1, n-1):
if hrs > arr[i] - arr[i+1]:
hrs = arr[i] - arr[i+1]
print(hrs)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
You have been appointed as the designer for your school's computer network.
In total, there are N computers in the class, and M computer-to-computer connections need to be made. Also, there are three mandatory conditions the design should fulfill.
The first requirement is that any computer in the network should be able to communicate with any other computer through the connections, possibly, through some other computers.
Network attacks are possible, so the second requirement is that even if any one computer from the network gets disabled so that the rest of the computers are unable to communicate with it, the rest of the computers can still communicate with each other. In other words, the first requirement still holds for any subset of (N-1) computers.
The third requirement is that there shouldn't be any irrelevant connections in the network. We will call a connection irrelevant if and only if after its' removal, the above two requirements are still held.
Given N, M, please build a network with N computers and M connections, or state that it is impossible.
-----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 and only line of each test case contains a pair of space-separated integers N and M denoting the number of computers and the number of connections.
-----Output-----
Output T blocks.
If it is impossible to construct a network with the given parameters for the corresponding test case, output just -1 -1. Otherwise, output M lines, each of which contains a space-separated pairs of integers denoting the IDs of the computers that should be connected. Note that multiple connections between any pair of computers and connections connecting a computer to itself are implicitly not allowed due to the third requirement.
-----Constraints-----
- 1 ≤ T ≤ 1000
- 1 ≤ M ≤ N * (N - 1) / 2
- 1 ≤ Sum of all N ≤ 1000
- Subtask 1 (21 point): 1 ≤ N ≤ 4
- Subtask 2 (79 points): 1 ≤ N ≤ 100
-----Example-----
Input:2
10 1
5 5
Output:-1 -1
1 2
2 3
3 4
4 5
5 1
-----Explanation-----
Example case 1. There are not enough connections even to satisfy the first requirement.
Example case 2. The obtained network satisfies all the requirements.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
import fractions
import sys
f = sys.stdin
if len(sys.argv) > 1:
f = open(sys.argv[1], "rt")
def calc(N, M):
if M != N:
return [(-1, -1)]
r = [(i+1, ((i+1) % N)+1) for i in range(N)]
return r
T = int(f.readline().strip())
for case_id in range(1, T+1):
N, M = list(map(int, f.readline().strip().split()))
rr = calc(N, M)
for a, b in rr:
print(a, b)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
You might have heard about the next game in Lara Croft series coming out this year. You also might have watched its trailer. Though you definitely missed the main idea about its plot, so let me lift the veil of secrecy.
Lara is going to explore yet another dangerous dungeon. Game designers decided to use good old 2D environment. The dungeon can be represented as a rectangle matrix of n rows and m columns. Cell (x, y) is the cell in the x-th row in the y-th column. Lara can move between the neighbouring by side cells in all four directions.
Moreover, she has even chosen the path for herself to avoid all the traps. She enters the dungeon in cell (1, 1), that is top left corner of the matrix. Then she goes down all the way to cell (n, 1) — the bottom left corner. Then she starts moving in the snake fashion — all the way to the right, one cell up, then to the left to the cell in 2-nd column, one cell up. She moves until she runs out of non-visited cells. n and m given are such that she always end up in cell (1, 2).
Lara has already moved to a neighbouring cell k times. Can you determine her current position?
-----Input-----
The only line contains three integers n, m and k (2 ≤ n, m ≤ 10^9, n is always even, 0 ≤ k < n·m). Note that k doesn't fit into 32-bit integer type!
-----Output-----
Print the cell (the row and the column where the cell is situated) where Lara ends up after she moves k times.
-----Examples-----
Input
4 3 0
Output
1 1
Input
4 3 11
Output
1 2
Input
4 3 7
Output
3 2
-----Note-----
Here is her path on matrix 4 by 3: [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, k = map(int, input().split())
ans = 0, 0
if k < n:
ans = k + 1, 1
else:
k -= n
r = n - k // (m - 1)
if r % 2:
c = m - k % (m - 1)
else:
c = 2 + k % (m - 1)
ans = r, c
print(*ans)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
When Serezha was three years old, he was given a set of cards with letters for his birthday. They were arranged into words in the way which formed the boy's mother favorite number in binary notation. Serezha started playing with them immediately and shuffled them because he wasn't yet able to read. His father decided to rearrange them. Help him restore the original number, on condition that it was the maximum possible one.
-----Input-----
The first line contains a single integer $n$ ($1 \leqslant n \leqslant 10^5$) — the length of the string. The second line contains a string consisting of English lowercase letters: 'z', 'e', 'r', 'o' and 'n'.
It is guaranteed that it is possible to rearrange the letters in such a way that they form a sequence of words, each being either "zero" which corresponds to the digit $0$ or "one" which corresponds to the digit $1$.
-----Output-----
Print the maximum possible number in binary notation. Print binary digits separated by a space. The leading zeroes are allowed.
-----Examples-----
Input
4
ezor
Output
0
Input
10
nznooeeoer
Output
1 1 0
-----Note-----
In the first example, the correct initial ordering is "zero".
In the second example, the correct initial ordering is "oneonezero".
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 = int(input())
arr = input()
one = arr.count('n')
zero = arr.count('z')
ans = [1] * one + [0] * zero
print(*ans)
return 0
main()
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Absent-minded Masha got set of n cubes for her birthday.
At each of 6 faces of each cube, there is exactly one digit from 0 to 9. Masha became interested what is the largest natural x such she can make using her new cubes all integers from 1 to x.
To make a number Masha can rotate her cubes and put them in a row. After that, she looks at upper faces of cubes from left to right and reads the number.
The number can't contain leading zeros. It's not required to use all cubes to build a number.
Pay attention: Masha can't make digit 6 from digit 9 and vice-versa using cube rotations.
-----Input-----
In first line integer n is given (1 ≤ n ≤ 3) — the number of cubes, Masha got for her birthday.
Each of next n lines contains 6 integers a_{i}_{j} (0 ≤ a_{i}_{j} ≤ 9) — number on j-th face of i-th cube.
-----Output-----
Print single integer — maximum number x such Masha can make any integers from 1 to x using her cubes or 0 if Masha can't make even 1.
-----Examples-----
Input
3
0 1 2 3 4 5
6 7 8 9 0 1
2 3 4 5 6 7
Output
87
Input
3
0 1 3 5 6 8
1 2 4 5 7 8
2 3 4 6 7 9
Output
98
-----Note-----
In the first test case, Masha can build all numbers from 1 to 87, but she can't make 88 because there are no two cubes with digit 8.
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 = sorted([list(map(int, input().split())) for i in range(n)])
import itertools
for x in range(1,10**n):
good = False
s = str(x)
for p in itertools.permutations(a, len(s)):
good |= all([int(s[i]) in v for i, v in enumerate(p)])
if not good:
print(x-1)
return
print((10**n)-1)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
You are given a grid of size M x N, where each square is colored with some random color among K colors with each having equal probability.
A Good Rectangle is defined as one where all squares lying on the inner border are of the same color.
What is the expected number of Good Rectangles in the given grid.
-----Input-----
-
First Line contains M, N, K
-----Output-----
A single value rounded off to the nearest Integer corresponding to the required answer.
-----Constraints-----
- 1 <= N <= 105
- 1 <= M <= 105
- 1 <= K <= 105
-----Example-----
Input:
1 3 1
Output:
6
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
def for1(M,k):
ret = 0.0
x = k*k+0.0
z=x
for m in range(1,M):
ret+=(M-m)/x
x*=z
return ret
def for2(M,k):
ret = 0.0
x = k+0.0
for m in range(1,M):
ret+=(M-m)/x
x*=k
return ret
def ans(M,N,K):
return int(round(M*N+M*for2(N,K)+N*for2(M,K)+K*for1(M,K)*for1(N,K),0))
M,N,K = list(map(int,input().split()))
print(ans(M,N,K))
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
You are given a string $S$ and an integer $L$. A operation is described as :- "You are allowed to pick any substring from first $L$ charcaters of $S$, and place it at the end of the string $S$.
A string $A$ is a substring of an string $B$ if $A$ can be obtained from $B$ by deletion of several (possibly, zero or all) characters from the beginning and several (possibly, zero or all) elements from the end.
Find the lexographically smallest string after performing this opertaion any number of times (possibly zero).
For example $S$ = "codechef" and $L=4$. Then, we can take substring "ode" from S[0-3] and place it at end of the string $S$ = "cchefode".
-----Input:-----
- First line will contain $T$, number of testcases.
- Then each of the N lines contain an integer $L$ and a string $S$.
-----Output:-----
For each testcase, output in a single line answer lexographically smallest string.
-----Constraints-----
- $1 \leq T \leq 10^4$
- $2 \leq |S| \leq 10^3$
- $1 \leq L \leq N $
-----Sample Input:-----
2
1 rga
2 cab
-----Sample Output:-----
arg
abc
-----EXPLANATION:-----
In the first testcase:
substring 'r' is picked and placed at the end of the string. rga -> gar
Then performing same operation gives :- gar -> arg
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
def least_rotation(S: str) -> int:
"""Booth's algorithm."""
f = [-1] * len(S) # Failure function
k = 0 # Least rotation of string found so far
for j in range(1, len(S)):
sj = S[j]
i = f[j - k - 1]
while i != -1 and sj != S[k + i + 1]:
if sj < S[k + i + 1]:
k = j - i - 1
i = f[i]
if sj != S[k + i + 1]: # if sj != S[k+i+1], then i == -1
if sj < S[k]: # k+i+1 = k
k = j
f[j - k] = -1
else:
f[j - k] = i + 1
return k
for _ in range(int(input())):
l, s = input().split()
if int(l) == 1:
l = len(s)
s += s
k = least_rotation(s)
print(s[k:k+l])
else:
print(''.join(sorted(s)))
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
You are given a Young diagram.
Given diagram is a histogram with $n$ columns of lengths $a_1, a_2, \ldots, a_n$ ($a_1 \geq a_2 \geq \ldots \geq a_n \geq 1$). [Image] Young diagram for $a=[3,2,2,2,1]$.
Your goal is to find the largest number of non-overlapping dominos that you can draw inside of this histogram, a domino is a $1 \times 2$ or $2 \times 1$ rectangle.
-----Input-----
The first line of input contain one integer $n$ ($1 \leq n \leq 300\,000$): the number of columns in the given histogram.
The next line of input contains $n$ integers $a_1, a_2, \ldots, a_n$ ($1 \leq a_i \leq 300\,000, a_i \geq a_{i+1}$): the lengths of columns.
-----Output-----
Output one integer: the largest number of non-overlapping dominos that you can draw inside of the given Young diagram.
-----Example-----
Input
5
3 2 2 2 1
Output
4
-----Note-----
Some of the possible solutions for the example:
[Image] $\square$
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
import sys
readline = sys.stdin.readline
N = int(readline())
A = list(map(int, readline().split()))
BW = [0, 0]
for i in range(N):
a = A[i]
BW[i%2] += a//2
BW[(i+1)%2] += -(-a//2)
print(min(BW))
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
The biggest event of the year – Cota 2 world championship "The Innernational" is right around the corner. $2^n$ teams will compete in a double-elimination format (please, carefully read problem statement even if you know what is it) to identify the champion.
Teams are numbered from $1$ to $2^n$ and will play games one-on-one. All teams start in the upper bracket.
All upper bracket matches will be held played between teams that haven't lost any games yet. Teams are split into games by team numbers. Game winner advances in the next round of upper bracket, losers drop into the lower bracket.
Lower bracket starts with $2^{n-1}$ teams that lost the first upper bracket game. Each lower bracket round consists of two games. In the first game of a round $2^k$ teams play a game with each other (teams are split into games by team numbers). $2^{k-1}$ loosing teams are eliminated from the championship, $2^{k-1}$ winning teams are playing $2^{k-1}$ teams that got eliminated in this round of upper bracket (again, teams are split into games by team numbers). As a result of each round both upper and lower bracket have $2^{k-1}$ teams remaining. See example notes for better understanding.
Single remaining team of upper bracket plays with single remaining team of lower bracket in grand-finals to identify championship winner.
You are a fan of teams with numbers $a_1, a_2, ..., a_k$. You want the championship to have as many games with your favourite teams as possible. Luckily, you can affect results of every championship game the way you want. What's maximal possible number of championship games that include teams you're fan of?
-----Input-----
First input line has two integers $n, k$ — $2^n$ teams are competing in the championship. You are a fan of $k$ teams ($2 \le n \le 17; 0 \le k \le 2^n$).
Second input line has $k$ distinct integers $a_1, \ldots, a_k$ — numbers of teams you're a fan of ($1 \le a_i \le 2^n$).
-----Output-----
Output single integer — maximal possible number of championship games that include teams you're fan of.
-----Examples-----
Input
3 1
6
Output
6
Input
3 3
1 7 8
Output
11
Input
3 4
1 3 5 7
Output
14
-----Note-----
On the image, each game of the championship is denoted with an English letter ($a$ to $n$). Winner of game $i$ is denoted as $Wi$, loser is denoted as $Li$. Teams you're a fan of are highlighted with red background.
In the first example, team $6$ will play in 6 games if it looses the first upper bracket game (game $c$) and wins all lower bracket games (games $h, j, l, m$). [Image]
In the second example, teams $7$ and $8$ have to play with each other in the first game of upper bracket (game $d$). Team $8$ can win all remaining games in upper bracket, when teams $1$ and $7$ will compete in the lower bracket. [Image]
In the third example, your favourite teams can play in all games of the championship. [Image]
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,k=list(map(int,input().split()))
if k==0:
print(0)
return
A=sorted(map(int,input().split()))
# DP[UL][n][left]
# [left*pow(2,n),left*pow(2,n)+pow(2,n))の間のチームで,
# ファンのチームが
# UL=0: upperでもlowerでも勝ち残っている
# UL=1: upperでのみ勝ち残っている
# UL=2: lowerでのみ勝ち残っている
# ときの、そこまでのファンのチームの試合数の最大値.
DP=[[[0]*((1<<n)+2) for i in range(n+1)] for UL in range(3)]
for i in range(k):
if A[i]%2==1:
DP[1][1][A[i]]=1
DP[2][1][A[i]]=1
else:
DP[1][1][A[i]-1]=1
DP[2][1][A[i]-1]=1
if i<k-1 and A[i]%2==1 and A[i+1]==A[i]+1:
DP[0][1][A[i]]=1
for i in range(2,n+1):
for left in range(1,(1<<n)+1,1<<i):
if DP[0][i-1][left]:
DP[0][i][left]=max(DP[0][i-1][left] + DP[0][i-1][left+(1<<(i-1))] + 3,DP[0][i-1][left] + DP[1][i-1][left+(1<<(i-1))] + 3,\
DP[0][i-1][left] + DP[2][i-1][left+(1<<(i-1))] + 3)
if DP[0][i-1][left+(1<<(i-1))]:
DP[0][i][left]=max(DP[0][i][left], DP[0][i-1][left] + DP[0][i-1][left+(1<<(i-1))] + 3,\
DP[1][i-1][left] + DP[0][i-1][left+(1<<(i-1))] + 3,DP[2][i-1][left] + DP[0][i-1][left+(1<<(i-1))] + 3)
if DP[1][i-1][left]:
DP[1][i][left]=max(DP[1][i][left], DP[1][i-1][left] + 1)
DP[2][i][left]=max(DP[2][i][left], DP[1][i-1][left] + 2)
if DP[2][i-1][left]:
DP[2][i][left]=max(DP[2][i][left], DP[2][i-1][left] + 2)
if DP[1][i-1][left+(1<<(i-1))]:
DP[1][i][left]=max(DP[1][i][left], DP[1][i-1][left+(1<<(i-1))] + 1)
DP[2][i][left]=max(DP[2][i][left], DP[1][i-1][left+(1<<(i-1))] + 2)
if DP[2][i-1][left+(1<<(i-1))]:
DP[2][i][left]=max(DP[2][i][left], DP[2][i-1][left+(1<<(i-1))] + 2)
if DP[1][i-1][left] and DP[1][i-1][left+(1<<(i-1))]:
DP[0][i][left]=max(DP[0][i][left], DP[1][i-1][left] + DP[1][i-1][left+(1<<(i-1))] + 2)
if DP[1][i-1][left] and DP[2][i-1][left+(1<<(i-1))]:
DP[0][i][left]=max(DP[0][i][left], DP[1][i-1][left] + DP[2][i-1][left+(1<<(i-1))] + 3)
if DP[2][i-1][left] and DP[1][i-1][left+(1<<(i-1))]:
DP[0][i][left]=max(DP[0][i][left], DP[2][i-1][left] + DP[1][i-1][left+(1<<(i-1))] + 3)
if DP[2][i-1][left] and DP[2][i-1][left+(1<<(i-1))]:
DP[2][i][left]=max(DP[2][i][left], DP[2][i-1][left] + DP[2][i-1][left+(1<<(i-1))] + 2)
"""
for i in range(n+1):
print(DP[0][i])
print()
for i in range(n+1):
print(DP[1][i])
print()
for i in range(n+1):
print(DP[2][i])
print()
for i in range(n+1):
print(DP[0][0][i])
"""
print(max(DP[0][n][1],DP[1][n][1],DP[2][n][1])+1)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
In some country there are exactly n cities and m bidirectional roads connecting the cities. Cities are numbered with integers from 1 to n. If cities a and b are connected by a road, then in an hour you can go along this road either from city a to city b, or from city b to city a. The road network is such that from any city you can get to any other one by moving along the roads.
You want to destroy the largest possible number of roads in the country so that the remaining roads would allow you to get from city s_1 to city t_1 in at most l_1 hours and get from city s_2 to city t_2 in at most l_2 hours.
Determine what maximum number of roads you need to destroy in order to meet the condition of your plan. If it is impossible to reach the desired result, print -1.
-----Input-----
The first line contains two integers n, m (1 ≤ n ≤ 3000, $n - 1 \leq m \leq \operatorname{min} \{3000, \frac{n(n - 1)}{2} \}$) — the number of cities and roads in the country, respectively.
Next m lines contain the descriptions of the roads as pairs of integers a_{i}, b_{i} (1 ≤ a_{i}, b_{i} ≤ n, a_{i} ≠ b_{i}). It is guaranteed that the roads that are given in the description can transport you from any city to any other one. It is guaranteed that each pair of cities has at most one road between them.
The last two lines contains three integers each, s_1, t_1, l_1 and s_2, t_2, l_2, respectively (1 ≤ s_{i}, t_{i} ≤ n, 0 ≤ l_{i} ≤ n).
-----Output-----
Print a single number — the answer to the problem. If the it is impossible to meet the conditions, print -1.
-----Examples-----
Input
5 4
1 2
2 3
3 4
4 5
1 3 2
3 5 2
Output
0
Input
5 4
1 2
2 3
3 4
4 5
1 3 2
2 4 2
Output
1
Input
5 4
1 2
2 3
3 4
4 5
1 3 2
3 5 1
Output
-1
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
from itertools import combinations_with_replacement
from collections import deque
#sys.stdin = open("input_py.txt","r")
n, m = map(int, input().split())
G = [ [] for i in range(n)]
for i in range(m):
x, y = map(int, input().split())
x-=1; y-=1
G[x].append(y)
G[y].append(x)
def BFS(s):
dist = [-1 for i in range(n)]
dist[s] = 0
Q = deque()
Q.append(s)
while len(Q) > 0:
v = Q.popleft()
for to in G[v]:
if dist[to] < 0:
dist[to] = dist[v] + 1
Q.append(to)
return dist
Dist = [BFS(i) for i in range(n)]
s1, t1, l1 = map(int, input(). split())
s2, t2, l2 = map(int, input(). split())
s1-=1; t1-=1; s2-=1; t2-=1
if Dist[s1][t1] > l1 or Dist[s2][t2] > l2:
print(-1)
return
rest = Dist[s1][t1] + Dist[s2][t2]
for i in range(n):
for j in range(n):
if Dist[i][s1] + Dist[i][j] + Dist[j][t1] <= l1 and Dist[i][s2] + Dist[i][j] + Dist[j][t2] <= l2 :
rest = min(rest, Dist[i][j] + Dist[i][s1] + Dist[i][s2] + Dist[j][t1] + Dist[j][t2])
if Dist[i][s1] + Dist[i][j] + Dist[j][t1] <= l1 and Dist[j][s2] + Dist[i][j] + Dist[i][t2] <= l2 :
rest = min(rest, Dist[i][j] + Dist[j][t1] + Dist[j][s2] + Dist[i][s1] + Dist[i][t2])
print(m-rest)
``` |
|
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 want all the elements of the sequence to be equal. In order to achieve that, you may perform zero or more moves. In each move, you must choose an index $i$ ($1 \le i \le N$), then choose $j = i-1$ or $j = i+1$ (it is not allowed to choose $j = 0$ or $j = N+1$) and change the value of $A_i$ to $A_j$ — in other words, you should replace the value of one element of the sequence by one of its adjacent elements.
What is the minimum number of moves you need to make in order to make all the elements of the sequence equal?
-----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 minimum required number of moves.
-----Constraints-----
- $1 \le T \le 100$
- $1 \le N \le 100$
- $1 \le A_i \le 100$ for each valid $i$
-----Example Input-----
3
5
1 1 1 1 1
4
9 8 1 8
2
1 9
-----Example Output-----
0
2
1
-----Explanation-----
Example case 1: No moves are needed since all the elements are already equal.
Example case 3: We can perform one move on either $A_1$ or $A_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=int(input())
a=[int(z) for z in input().split()]
m=0
a1=list(set(a))
for i in range(len(a1)):
if a.count(a1[i])>m:
m=a.count(a1[i])
print(n-m)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Chef received a new sequence $A_1, A_2, \ldots, A_N$. He does not like arbitrarily ordered sequences, so he wants to permute the elements of $A$ in such a way that it would satisfy the following condition: there is an integer $p$ ($1 \le p \le N$) such that the first $p$ elements of the new (permuted) sequence are strictly increasing and the last $N-p+1$ elements are strictly decreasing.
Help Chef and find a permutation of the given sequence which satisfies this condition or determine that no such permutation exists. If there are multiple solutions, you may find any one.
-----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:
- If there is no permutation of $A$ that satisfies the given condition, print a single line containing the string "NO" (without quotes).
- Otherwise, print two lines.
- The first of these lines should contain the string "YES" (without quotes).
- The second line should contain $N$ space-separated integers ― the elements of your permuted sequence.
-----Constraints-----
- $1 \le T \le 100$
- $1 \le N \le 10^5$
- $1 \le A_i \le 2 \cdot 10^5$ for each valid $i$
- the sum of $N$ over all test cases does not exceed $10^6$
-----Subtasks-----
Subtask #1 (50 points):
- $N \le 10^3$
- $A_i \le 2 \cdot 10^3$ for each valid $i$
- the sum of $N$ over all test cases does not exceed $10^4$
Subtask #2 (50 points): original constraints
-----Example Input-----
5
4
1 3 2 4
4
1 3 2 4
6
1 10 10 10 20 15
5
1 1 2 2 3
4
1 2 3 3
-----Example Output-----
YES
1 2 3 4
YES
4 3 2 1
NO
YES
1 2 3 2 1
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())):
n = int(input())
arr= list(map(int,input().split()))
arr.sort()
d={}
for i in arr:
if i not in d:
d[i]=1
else:
d[i]+=1
flag = True
for i in d:
if d[i]>2:
flag=False
break
if arr.count(max(arr))!=1:
flag=False
if flag==True:
arr1=[]
arr2=[]
for i in d:
if d[i]<=2:
if d[i]==2:
arr2.append(i)
arr1.append(i)
arr2.reverse()
rearr= arr1+arr2
print("YES")
print(*rearr)
else:
print("NO")
# cook your dish here
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Ms. E.T. came from planet Hex. She has 8 fingers in each hand which makes her count in hexadecimal way. When she meets you, she tells you that she came from 7E light years from the planet Earth. You see she means that it is 126 light years far away and she is telling you the numbers in hexadecimal. Now, you are in trouble to understand what those numbers really mean. Therefore, you have to convert the hexadecimal numbers to decimals.
Input:
First line of code contain T test cases.
every line of text case contain a Hex-value
Output:
Every line of output contain a decimal conversion of given nunmber
Sample Input:
3
A
1A23
2C2A
Sample Output:
10
6691
11306
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
try:
t=int(input())
for i in range(t):
s=input()
i=int(s,16)
print(i)
except EOFError as e:
print(e)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
A mad scientist Dr.Jubal has made a competitive programming task. Try to solve it!
You are given integers $n,k$. Construct a grid $A$ with size $n \times n$ consisting of integers $0$ and $1$. The very important condition should be satisfied: the sum of all elements in the grid is exactly $k$. In other words, the number of $1$ in the grid is equal to $k$.
Let's define: $A_{i,j}$ as the integer in the $i$-th row and the $j$-th column. $R_i = A_{i,1}+A_{i,2}+...+A_{i,n}$ (for all $1 \le i \le n$). $C_j = A_{1,j}+A_{2,j}+...+A_{n,j}$ (for all $1 \le j \le n$). In other words, $R_i$ are row sums and $C_j$ are column sums of the grid $A$. For the grid $A$ let's define the value $f(A) = (\max(R)-\min(R))^2 + (\max(C)-\min(C))^2$ (here for an integer sequence $X$ we define $\max(X)$ as the maximum value in $X$ and $\min(X)$ as the minimum value in $X$).
Find any grid $A$, which satisfies the following condition. Among such grids find any, for which the value $f(A)$ is the minimum possible. Among such tables, you can find any.
-----Input-----
The input consists of multiple test cases. The first line contains a single integer $t$ ($1 \le t \le 100$) — the number of test cases. Next $t$ lines contain descriptions of test cases.
For each test case the only line contains two integers $n$, $k$ $(1 \le n \le 300, 0 \le k \le n^2)$.
It is guaranteed that the sum of $n^2$ for all test cases does not exceed $10^5$.
-----Output-----
For each test case, firstly print the minimum possible value of $f(A)$ among all tables, for which the condition is satisfied.
After that, print $n$ lines contain $n$ characters each. The $j$-th character in the $i$-th line should be equal to $A_{i,j}$.
If there are multiple answers you can print any.
-----Example-----
Input
4
2 2
3 8
1 0
4 16
Output
0
10
01
2
111
111
101
0
0
0
1111
1111
1111
1111
-----Note-----
In the first test case, the sum of all elements in the grid is equal to $2$, so the condition is satisfied. $R_1 = 1, R_2 = 1$ and $C_1 = 1, C_2 = 1$. Then, $f(A) = (1-1)^2 + (1-1)^2 = 0$, which is the minimum possible value of $f(A)$.
In the second test case, the sum of all elements in the grid is equal to $8$, so the condition is satisfied. $R_1 = 3, R_2 = 3, R_3 = 2$ and $C_1 = 3, C_2 = 2, C_3 = 3$. Then, $f(A) = (3-2)^2 + (3-2)^2 = 2$. It can be proven, that it is the minimum possible value of $f(A)$.
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())
mat = [[0] * n for _ in range(n)]
for i in range(n):
b = False
for j in range(n):
if i*n+j == k:
b = True
break
mat[(i+j)%n][j] = 1
if b:
break
if k%n == 0:
print(0)
else:
print(2)
for i in range(n):
for j in range(n):
print(mat[i][j], end="")
print()
``` |
|
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 100$
- $1 \leq K \leq 100$
-----Sample Input:-----
3
2
3
4
-----Sample Output:-----
21
1
123
21
1
4321
123
21
1
-----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
for _ in range(int(input())):
n = int(input())
s = ''
for i in range(1, n + 1): s += str(i)
for i in range(n, 0, -1):
if i % 2 == 0:
for j in range(i, 0, -1): print(j, end = '')
else:
for j in range(1, i + 1): print(j, end = '')
print()
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
You must have tried to solve the Rubik’s cube. You might even have succeeded at it. Rubik’s cube is a 3x3x3 cube which has 6 different color for each face.The Rubik’s cube is made from 26 smaller pieces which are called cubies. There are 6 cubies at the centre of each face and these comprise of a single color. There are 8 cubies at the 8 corners which comprise of exactly 3 colors. The 12 reamaining cubies comprise of exactly 2 colors.
Apple has come up with a variation of the Rubik’s Cube, it’s the Rubik’s cuboid which has different colors on its 6 faces. The Rubik’s Cuboid comes in various sizes represented by M x N x O (M,N,O are natural numbers). Apple is giving away 100 Rubik’s cuboid for free to people who can answer a simple questions. Apple wants to know, in a Rubik’s cuboid with arbitrary dimensions, how many cubies would be there, which comprise of exactly 2 color.
-----Input-----
The input contains several test cases.The first line of the input contains an integer T denoting the number of test cases.
Each test case comprises of 3 natural numbers, M,N & O, which denote the dimensions of the Rubiks Cuboid.
-----Output-----
For each test case you are required to output the number of cubies which comprise of 2 squares, each of which is of a different color.
-----Constraints-----
- 1 ≤ T ≤ <1000
- 1 ≤ M ≤ <100000
- 1 ≤ N ≤ <100000
- 1 ≤ O ≤ <100000
-----Example-----
Input:
1
3
3
3
Output:
12
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())):
m=int(input())
n=int(input())
o=int(input())
ans=4*(m+n+o)-24
if(ans <= 0):
print('0')
else:
print(ans)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Bessie the cow and her best friend Elsie each received a sliding puzzle on Pi Day. Their puzzles consist of a 2 × 2 grid and three tiles labeled 'A', 'B', and 'C'. The three tiles sit on top of the grid, leaving one grid cell empty. To make a move, Bessie or Elsie can slide a tile adjacent to the empty cell into the empty cell as shown below: $\rightarrow$
In order to determine if they are truly Best Friends For Life (BFFLs), Bessie and Elsie would like to know if there exists a sequence of moves that takes their puzzles to the same configuration (moves can be performed in both puzzles). Two puzzles are considered to be in the same configuration if each tile is on top of the same grid cell in both puzzles. Since the tiles are labeled with letters, rotations and reflections are not allowed.
-----Input-----
The first two lines of the input consist of a 2 × 2 grid describing the initial configuration of Bessie's puzzle. The next two lines contain a 2 × 2 grid describing the initial configuration of Elsie's puzzle. The positions of the tiles are labeled 'A', 'B', and 'C', while the empty cell is labeled 'X'. It's guaranteed that both puzzles contain exactly one tile with each letter and exactly one empty position.
-----Output-----
Output "YES"(without quotes) if the puzzles can reach the same configuration (and Bessie and Elsie are truly BFFLs). Otherwise, print "NO" (without quotes).
-----Examples-----
Input
AB
XC
XB
AC
Output
YES
Input
AB
XC
AC
BX
Output
NO
-----Note-----
The solution to the first sample is described by the image. All Bessie needs to do is slide her 'A' tile down.
In the second sample, the two puzzles can never be in the same configuration. Perhaps Bessie and Elsie are not meant to be friends after all...
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
a, b, c, d = input(), input(), input(), input()
a = a + b[::-1]
x = "X"
for i in range(4):
if a[i] == x:
a = a[:i] + a[i + 1:]
break
c = c + d[::-1]
for i in range(4):
if c[i] == x:
c = c[:i] + c[i + 1:]
break
flag = False
for i in range(4):
if a == c:
flag = True
c = c[1:] + c[0]
if flag:
print("YES")
else:
print("NO")
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
There are $n$ segments $[l_i, r_i]$ for $1 \le i \le n$. You should divide all segments into two non-empty groups in such way that there is no pair of segments from different groups which have at least one common point, or say that it's impossible to do it. Each segment should belong to exactly one group.
To optimize testing process you will be given multitest.
-----Input-----
The first line contains one integer $T$ ($1 \le T \le 50000$) — the number of queries. Each query contains description of the set of segments. Queries are independent.
First line of each query contains single integer $n$ ($2 \le n \le 10^5$) — number of segments. It is guaranteed that $\sum{n}$ over all queries does not exceed $10^5$.
The next $n$ lines contains two integers $l_i$, $r_i$ per line ($1 \le l_i \le r_i \le 2 \cdot 10^5$) — the $i$-th segment.
-----Output-----
For each query print $n$ integers $t_1, t_2, \dots, t_n$ ($t_i \in \{1, 2\}$) — for each segment (in the same order as in the input) $t_i$ equals $1$ if the $i$-th segment will belongs to the first group and $2$ otherwise.
If there are multiple answers, you can print any of them. If there is no answer, print $-1$.
-----Example-----
Input
3
2
5 5
2 3
3
3 5
2 3
2 3
3
3 3
4 4
5 5
Output
2 1
-1
1 1 2
-----Note-----
In the first query the first and the second segments should be in different groups, but exact numbers don't matter.
In the second query the third segment intersects with the first and the second segments, so they should be in the same group, but then the other group becomes empty, so answer is $-1$.
In the third query we can distribute segments in any way that makes groups non-empty, so any answer of $6$ possible is correct.
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 ti in range(t):
n = int(input())
lri = [None for _ in range(n)]
for _ in range(n):
li, ri = list(map(int, input().split()))
lri[_] = (li, ri, _)
lri.sort()
t = [None for _ in range(n)]
ct, t[lri[0][2]], eg = 1, 1, lri[0][1]
for i in range(1, n):
if lri[i][0] <= eg:
t[lri[i][2]] = ct
eg = max(eg, lri[i][1])
else:
ct = 3 - ct
t[lri[i][2]] = ct
eg = lri[i][1]
if all(ti == 1 for ti in t):
print(-1)
else:
print(*t)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
You have an array a consisting of n integers. Each integer from 1 to n appears exactly once in this array.
For some indices i (1 ≤ i ≤ n - 1) it is possible to swap i-th element with (i + 1)-th, for other indices it is not possible. You may perform any number of swapping operations any order. There is no limit on the number of times you swap i-th element with (i + 1)-th (if the position is not forbidden).
Can you make this array sorted in ascending order performing some sequence of swapping operations?
-----Input-----
The first line contains one integer n (2 ≤ n ≤ 200000) — the number of elements in the array.
The second line contains n integers a_1, a_2, ..., a_{n} (1 ≤ a_{i} ≤ 200000) — the elements of the array. Each integer from 1 to n appears exactly once.
The third line contains a string of n - 1 characters, each character is either 0 or 1. If i-th character is 1, then you can swap i-th element with (i + 1)-th any number of times, otherwise it is forbidden to swap i-th element with (i + 1)-th.
-----Output-----
If it is possible to sort the array in ascending order using any sequence of swaps you are allowed to make, print YES. Otherwise, print NO.
-----Examples-----
Input
6
1 2 5 3 4 6
01110
Output
YES
Input
6
1 2 5 3 4 6
01010
Output
NO
-----Note-----
In the first example you may swap a_3 and a_4, and then swap a_4 and a_5.
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 = list(map(int,input().split()))
p = input()
m = 0
suc = True
for i in range(n-1):
m = max(m,a[i])
if p[i] == '0' and m>(i+1):
suc = False
break
if suc:
print('YES')
else:
print('NO')
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
"If you didn't copy assignments during your engineering course, did you even do engineering?"
There are $Q$ students in Chef's class. Chef's teacher has given the students a simple assignment:
Write a function that takes as arguments an array $A$ containing only unique elements and a number $X$ guaranteed to be present in the array and returns the ($1$-based) index of the element that is equal to $X$.
The teacher was expecting a linear search algorithm, but since Chef is such an amazing programmer, he decided to write the following binary search function:
integer binary_search(array a, integer n, integer x):
integer low, high, mid
low := 1
high := n
while low ≤ high:
mid := (low + high) / 2
if a[mid] == x:
break
else if a[mid] is less than x:
low := mid+1
else:
high := mid-1
return mid
All of Chef's classmates have copied his code and submitted it to the teacher.
Chef later realised that since he forgot to sort the array, the binary search algorithm may not work. Luckily, the teacher is tired today, so she asked Chef to assist her with grading the codes. Each student's code is graded by providing an array $A$ and an integer $X$ to it and checking if the returned index is correct. However, the teacher is lazy and provides the exact same array to all codes. The only thing that varies is the value of $X$.
Chef was asked to type in the inputs. He decides that when typing in the input array for each code, he's not going to use the input array he's given, but an array created by swapping some pairs of elements of this original input array. However, he cannot change the position of the element that's equal to $X$ itself, since that would be suspicious.
For each of the $Q$ students, Chef would like to know the minimum number of swaps required to make the algorithm find the correct answer.
-----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 $Q$ denoting the number of elements in the array and the number of students.
- The second line contains $N$ space-separated integers $A_1, A_2, \dots, A_N$.
- The following $Q$ lines describe queries. Each of these lines contains a single integer $X$.
-----Output-----
For each query, print a single line containing one integer — the minimum required number of swaps, or $-1$ if it is impossible to make the algorithm find the correct answer. (Do you really think Chef can fail?)
-----Constraints-----
- $1 \le T \le 10$
- $1 \le N, Q \le 10^5$
- $1 \le A_i \le 10^9$ for each valid $i$
- $1 \le X \le 10^9$
- all elements of $A$ are pairwise distinct
- for each query, $X$ is present in $A$
- sum of $N$ over all test cases $\le 5\cdot10^5$
- sum of $Q$ over all test cases $\le 5\cdot10^5$
-----Subtasks-----
Subtask #1 (20 points): $1 \le N \le 10$
Subtask #2 (30 points):
- $1 \le A_i \le 10^6$ for each valid $i$
- $1 \le X \le 10^6$
Subtask #3 (50 points): original constraints
-----Example Input-----
1
7 7
3 1 6 7 2 5 4
1
2
3
4
5
6
7
-----Example Output-----
0
1
1
2
1
0
0
-----Explanation-----
Example case 1:
- Query 1: The algorithm works without any swaps.
- Query 2: One solution is to swap $A_2$ and $A_4$.
- Query 3: One solution is to swap $A_2$ and $A_6$.
- Query 4: One solution is to swap $A_2$ with $A_4$ and $A_5$ with $A_6$.
- Query 5: One solution is to swap $A_2$ and $A_4$.
- Query 6: The algorithm works without any swaps.
- Query 7: The algorithm works without any swaps.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
def f(a,y,index,sorted_pos):
#print(a,y,index,sorted_pos)
n=len(a)
low=0
high=n-1
L,R=0,0
l,r=0,0
while(low<=high):
mid=(low+high)//2
#print(low,high,mid)
if(a[mid]== y):
break
elif(mid > index[y]):
high=mid-1
L+=1
#print("L")
if(a[mid] <y):
l+=1
#print(" l ")
else:
low=mid+1
R+=1
#print("R")
if(a[mid]>y):
r+=1
#print("r")
x=sorted_pos[y]
#print(L,R,l,r,x,n-x-1)
if(R>x or L> n-x-1):
print("-1")
else:
print(max(l,r))
def fun():
test=int(input())
for t in range(test):
n,q=list(map(int,input().split()))
arr=list(map(int,input().split()))
index= dict()
for i in range(n):
index[arr[i]]=i
sorted_pos=dict()
a=sorted(arr)
for i in range(n):
sorted_pos[a[i]]=i
for x in range(q):
y=int(input())
f(arr,y,index,sorted_pos)
fun()
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
The Petrozavodsk camp takes place in about one month. Jafar wants to participate in the camp, but guess what? His coach is Yalalovichik.
Yalalovichik is a legendary coach, famous in the history of competitive programming. However, he is only willing to send to the camp students who solve really hard problems on Timus. The deadline that Yalalovichik set before has passed and he refuses to send Jafar to the camp.
Jafar decided to make Yalalovichik happy in hopes of changing his decision, so he invented a new sequence of numbers and named them Yalalovichik numbers. Jafar is writing a research paper about their properties and wants to publish it in the Science Eagle yearly journal.
A Yalalovichik number is created in the following way:
- Consider an integer $N$ in decimal notation; let's call it the base of the Yalalovichik number $Y_N$. $N$ may not contain the digit $0$.
- Treat $N$ as a decimal string. Compute all left shifts of this string $N_0, N_1, \ldots, N_{|N|-1}$ ($|N|$ denotes the number of digits of $N$); specifically, $N_k$ denotes the string formed by moving the first $k$ digits of $N$ to the end in the same order.
- Concatenate the strings $N_0, N_1, \ldots, N_{|N|-1}$. The resulting string is the decimal notation of $Y_N$.
For example, if $N = 123$, the left shifts are $123, 231, 312$ and thus $Y_N = 123231312$.
You are given the base $N$. Calculate the value of $Y_N$ 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 a single decimal integer $N$.
-----Output-----
For each test case, print a single line containing one integer — the value of the Yalalovichik number $Y_N$ modulo $10^9+7$.
-----Constraints-----
- $1 \le T \le 200$
- $|N| \le 10^5$
- $N$ does not contain the digit $0$
- the sum of $|N|$ over all test cases does not exceed $10^6$
-----Example Input-----
1
123
-----Example Output-----
123231312
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
M = 10 ** 9 + 7
for _ in range(int(input())):
s,p,m,r = list(map(int, input())),0,1,0
for d in reversed(s):
p += d * m
m = m * 10 % M
for d in s:
r = (r * m + p) % M
p = (p * 10 - (m - 1) * d) % M
print(r)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Consider an infinite full binary tree (each node has two children except the leaf nodes) defined as follows. For a node labelled v its left child will be labelled 2*v and its right child will be labelled 2*v+1. The root is labelled as 1.
You are given N queries of the form i j. For each query, you have to print the length of the shortest path between node labelled i and node labelled j.
-----Input-----
First line contains N, the number of queries. Each query consists of two space separated integers i and j in one line.
-----Output-----
For each query, print the required answer in one line.
-----Constraints-----
- 1 ≤ N ≤ 105
- 1 ≤ i,j ≤ 109
-----Example-----
Input:
3
1 2
2 3
4 3
Output:
1
2
3
-----Explanation-----
For first query, 1 is directly connected to 2 by an edge. Hence distance 1.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
t=eval(input())
for _ in range(t):
i,j=list(map(int,input().split()))
bi=bin(i)[2:]
bj=bin(j)[2:]
k=0
while k<(min(len(bi),len(bj))):
if bi[k]!=bj[k]:
break
else:
k+=1
print(len(bi)-k+len(bj)-k)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
in Chefland, there is a very famous street where $N$ types of street food (numbered $1$ through $N$) are offered. For each valid $i$, there are $S_i$ stores that offer food of the $i$-th type, the price of one piece of food of this type is $V_i$ (the same in each of these stores) and each day, $P_i$ people come to buy it; each of these people wants to buy one piece of food of the $i$-th type.
Chef is planning to open a new store at this street, where he would offer food of one of these $N$ types. Chef assumes that the people who want to buy the type of food he'd offer will split equally among all stores that offer it, and if this is impossible, i.e. the number of these people $p$ is not divisible by the number of these stores $s$, then only $\left\lfloor\frac{p}{s}\right\rfloor$ people will buy food from Chef.
Chef wants to maximise his daily profit. Help Chef choose which type of food to offer and find the maximum daily profit he can make.
-----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$.
- $N$ lines follow. For each $i$ ($1 \le i \le N$), the $i$-th of these lines contains three space-separated integers $S_i$, $P_i$ and $V_i$.
-----Output-----
For each test case, print a single line containing one integer ― the maximum profit.
-----Constraints-----
- $1 \le T \le 100$
- $1 \le N \le 100$
- $1 \le S_i, V_i, P_i \le 10,000$ for each valid $i$
-----Subtasks-----
Subtask #1 (100 points): original constraints
-----Example Input-----
2
3
4 6 8
2 6 6
1 4 3
1
7 7 4
-----Example Output-----
12
0
-----Explanation-----
Example case 1: Chef should offer food of the second type. On each day, two people would buy from him, so his daily profit would be $12$.
Example case 2: Chef has no option other than to offer the only type of food, but he does not expect anyone to buy from him anyway, so his daily profit is $0$.
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())
while(t):
n=int(input())
l=[]
for i in range(n):
l.append(list(map(int,input().split())));
m=[]
for i in l:
m.append((i[1]//(i[0]+1))*i[2])
res=max(m)
print(res)
t=t-1
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Rachel has some candies and she decided to distribute them among $N$ kids. The ith kid receives $A_i$ candies. The kids are happy iff the difference between the highest and lowest number of candies received is less than $X$.
Find out if the children are happy or not.
-----Input:-----
- First line will contain $T$, number of testcases. Then the testcases follow.
- The first line contains $N$ and $X$.
- The second line contains $N$ integers $A_1,A_2,...,A_N$.
-----Output:-----
For each test case print either "YES"(without quotes) if the kids are happy else "NO"(without quotes)
-----Constraints-----
- $1 \leq T \leq 100$
- $1 \leq N, X \leq 10^5$
- $1 \leq A_i \leq 10^5$
-----Sample Input:-----
2
5 6
3 5 6 8 1
3 10
5 2 9
-----Sample Output:-----
NO
YES
-----EXPLANATION:-----
- Example 1: Difference between maximum and minimum candies received is 8-1=7. 7 is greater than 6, therefore, the kids are not happy.
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 t1 in range(t):
n,x=map(int,input().split())
a=list(map(int,input().split()))
mx=max(a)
mn=min(a)
if (mx-mn<x):
print("YES")
else:
print("NO")
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Nauuo is a girl who loves drawing circles.
One day she has drawn a circle and wanted to draw a tree on it.
The tree is a connected undirected graph consisting of $n$ nodes and $n-1$ edges. The nodes are numbered from $1$ to $n$.
Nauuo wants to draw a tree on the circle, the nodes of the tree should be in $n$ distinct points on the circle, and the edges should be straight without crossing each other.
"Without crossing each other" means that every two edges have no common point or the only common point is an endpoint of both edges.
Nauuo wants to draw the tree using a permutation of $n$ elements. A permutation of $n$ elements is a sequence of integers $p_1,p_2,\ldots,p_n$ in which every integer from $1$ to $n$ appears exactly once.
After a permutation is chosen Nauuo draws the $i$-th node in the $p_i$-th point on the circle, then draws the edges connecting the nodes.
The tree is given, Nauuo wants to know how many permutations are there so that the tree drawn satisfies the rule (the edges are straight without crossing each other). She only wants to know the answer modulo $998244353$, can you help her?
It is obvious that whether a permutation is valid or not does not depend on which $n$ points on the circle are chosen.
-----Input-----
The first line contains a single integer $n$ ($2\le n\le 2\cdot 10^5$) — the number of nodes in the tree.
Each of the next $n-1$ lines contains two integers $u$ and $v$ ($1\le u,v\le n$), denoting there is an edge between $u$ and $v$.
It is guaranteed that the given edges form a tree.
-----Output-----
The output contains a single integer — the number of permutations suitable to draw the given tree on a circle satisfying the rule, modulo $998244353$.
-----Examples-----
Input
4
1 2
1 3
2 4
Output
16
Input
4
1 2
1 3
1 4
Output
24
-----Note-----
Example 1
All valid permutations and their spanning trees are as follows.
[Image]
Here is an example of invalid permutation: the edges $(1,3)$ and $(2,4)$ are crossed.
[Image]
Example 2
Every permutation leads to a valid tree, so the answer is $4! = 24$.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,copy,functools
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 998244353
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(): return [list(map(int, l.split())) for l in sys.stdin.readlines()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def pe(s): return print(str(s), file=sys.stderr)
def JA(a, sep): return sep.join(map(str, a))
def main():
n = I()
aa = [LI() for _ in range(n-1)]
e = collections.defaultdict(set)
for a,b in aa:
e[a].add(b)
e[b].add(a)
q = [[(1,-1)]]
qi = 0
while 1:
t = q[qi]
nq = []
for i,p in t:
for c in e[i]:
if c == p:
continue
nq.append((c,i))
if len(nq) < 1:
break
q.append(nq)
qi += 1
gm = [1]
for i in range(1,n+1):
gm.append(i*gm[-1]%mod)
m = {}
def f(i, p):
t = 1
r = 1
for c in e[i]:
if c == p:
continue
# print('c',c)
r *= m[c]
r %= mod
t += 1
if p == -1:
r *= gm[t-1]
r *= n
else:
r *= gm[t]
r %= mod
m[i] = r
# print('r',i,p,r)
# print('g',gm[t],t)
return r
for qt in q[::-1]:
for i,p in qt:
# print('ip', i,p)
f(i,p)
r = f(1,-1)
return r
print(main())
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
You are given a string $S$. Find the number of ways to choose an unordered pair of non-overlapping non-empty substrings of this string (let's denote them by $s_1$ and $s_2$ in such a way that $s_2$ starts after $s_1$ ends) such that their concatenation $s_1 + s_2$ is a palindrome.
Two pairs $(s_1, s_2)$ and $(s_1', s_2')$ are different if $s_1$ is chosen at a different position from $s_1'$ or $s_2$ is chosen at a different position from $s_2'$.
-----Input-----
The first and only line of the input contains a single string $S$.
-----Output-----
Print a single line containing one integer — the number of ways to choose a valid pair of substrings.
-----Constraints-----
- $1 \le |S| \le 1,000$
- $S$ contains only lowercase English letters
-----Subtasks-----
Subtask #1 (25 points): $|S| \le 100$
Subtask #2 (75 points): original constraints
-----Example Input-----
abba
-----Example Output-----
7
-----Explanation-----
The following pairs of substrings can be chosen: ("a", "a"), ("a", "ba"), ("a", "bba"), ("ab", "a"), ("ab", "ba"), ("abb", "a"), ("b", "b").
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
def binarySearch(arr, l, r, x):
mid=0
while l <= r:
mid = l + (r - l)//2;
if arr[mid] == x:
return mid+1
elif arr[mid] < x:
l = mid + 1
else:
r = mid - 1
if mid!=len(arr):
if arr[mid]<x:
return mid+1
return mid
s=input()
strt=[]
end=[]
plc=[]
landr=[]
l2r=[]
lr=[]
ans=0
n=len(s)
if n!=1:
for i in range(n):
strt.append([])
end.append([])
landr.append([0]*n)
l2r.append([0]*n)
for i in range(n):
for j in range(n):
if i-j<0 or i+j>=n:
break
if (s[i-j]==s[i+j]):
if i-j-1>=0:
strt[i-j-1].append(2*j+1)
if i+j+1<n:
end[i+j+1].append(2*j+1)
else:
break
for i in range(n):
for j in range(n):
if i-j<0 or i+j+1>=n:
break
if (s[i-j]==s[i+j+1]):
if i-j-1>=0:
strt[i-j-1].append(2*j+2)
if i+j+2<n:
end[i+j+2].append(2*j+2)
else:
break
for i in range(n):
end[i].sort()
strt[i].sort()
for i in range(n-1):
for j in range(i+1,n):
if s[i]==s[j]:
lr.append([i,j])
if i>0 and j<n-1:
landr[i][j]=landr[i-1][j+1]+1
else:
landr[i][j]=1
for i in lr:
tempans=1
l=i[0]
r=i[1]
length=r-l-1
tempans+=binarySearch(strt[l],0,len(strt[l])-1,length)
tempans+=binarySearch(end[r],0,len(end[r])-1,length)
l2r[l][r]=tempans
for i in range(n):
for j in range(n):
ans+=l2r[i][j]*landr[i][j]
print(ans)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
On her way to ChefLand, Marichka noticed $10^K$ road signs (numbered $0$ through $10^K - 1$). For each valid $i$, the sign with number $i$ had the integer $i$ written on one side and $10^K-i-1$ written on the other side.
Now, Marichka is wondering — how many road signs have exactly two distinct decimal digits written on them (on both sides in total)? Since this number may be large, compute it modulo $10^9+7$.
For example, if $K = 3$, the two integers written on the road sign $363$ are $363$ and $636$, and they contain two distinct digits $3$ and $6$, but on the road sign $362$, there are integers $362$ and $637$, which contain four distinct digits — $2$, $3$, $6$ and $7$. On the road sign $11$, there are integers $11$ and $988$, which contain three distinct digits — $1$, $9$ and $8$.
-----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 $K$.
-----Output-----
For each test case, print a single line containing one integer — the number of road signs with exactly two digits, modulo $10^9+7$.
-----Constraints-----
- $1 \le T \le 10^5$
- $1 \le K \le 10^9$
-----Subtasks-----
Subtask #1 (20 points): $1 \le T, K \le 5$
Subtask #2 (80 points): original constraints
-----Example Input-----
1
1
-----Example Output-----
10
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=int(input())
for i in range(t):
k=int(input())
res=((pow(2,k,1000000007))*5)%1000000007
print(res)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Did you know that there are over 40,000 varieties of Rice in the world ? There are so many dishes that can be prepared with Rice too. A famous chef from Mumbai, Tid Gusto prepared a new dish and named it 'Tid Rice'. He posted the recipe in his newly designed blog for community voting, where a user can plus (+) or minus (-) the recipe. The final score is just the sum of all votes, where (+) and (-) are treated as +1 and -1 respectively. But, being just a chef ( and not a codechef ) he forgot to take care of multiple votes by the same user.
A user might have voted multiple times and Tid is worried that the final score shown is not the correct one. Luckily, he found the user logs, which had all the N votes in the order they arrived. Remember that, if a user votes more than once, the user's previous vote is first nullified before the latest vote is counted ( see explanation for more clarity ). Given these records in order ( and being a codechef yourself :) ), calculate the correct final score.
-----Input-----
First line contains T ( number of testcases, around 20 ). T cases follow. Each test case starts with N ( total number of votes, 1 <= N <= 100 ). Each of the next N lines is of the form "userid vote" ( quotes for clarity only ), where userid is a non-empty string of lower-case alphabets ( 'a' - 'z' ) not more than 20 in length and vote is either a + or - . See the sample cases below, for more clarity.
-----Output-----
For each test case, output the correct final score in a new line
-----Example-----
Input:
3
4
tilak +
tilak +
tilak -
tilak +
3
ratna +
shashi -
ratna -
3
bhavani -
bhavani +
bhavani -
Output:
1
-2
-1
Explanation
Case 1 : Initially score = 0. Updation of scores in the order of user tilak's votes is as follows,
( + ): +1 is added to the final score. This is the 1st vote by this user, so no previous vote to nullify. score = 1
( + ): 0 should be added ( -1 to nullify previous (+) vote, +1 to count the current (+) vote ). score = 1
( - ) : -2 should be added ( -1 to nullify previous (+) vote, -1 to count the current (-) vote ). score = -1
( + ): +2 should be added ( +1 to nullify previous (-) vote, +1 to count the current (+) vote ). score = 1
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 f(p):
votes = {}
for x in range(p):
str = sys.stdin.readline()
t = str.split()
votes[t[0]] = t[1]
ans = 0
for per in votes:
if votes[per] == "+":
ans= ans+1
else:
ans = ans-1
return ans
x = sys.stdin.readline()
for t in range(int(x)):
p = sys.stdin.readline()
print(f(int(p)))
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Tennis is a popular game. Consider a simplified view of a tennis game from directly above. The game will appear to be played on a 2 dimensional rectangle, where each player has his own court, a half of the rectangle. Consider the players and the ball to be points moving on this 2D plane. The ball can be assumed to always move with fixed velocity (speed and direction) when it is hit by a player. The ball changes its velocity when hit by the other player. And so on, the game continues.
Chef also enjoys playing tennis, but in n+1$n + 1$ dimensions instead of just 3. From the perspective of the previously discussed overhead view, Chef's court is an n$n$-dimensional hyperrectangle which is axis-aligned with one corner at (0,0,0,…,0)$(0, 0, 0, \dots, 0)$ and the opposite corner at (l1,l2,l3,…,ln$(l_1, l_2, l_3, \dots, l_n$). The court of his opponent is the reflection of Chef's court across the n−1$n - 1$ dimensional surface with equation x1=0$x_1 = 0$.
At time t=0$t=0$, Chef notices that the ball is at position (0,b2,…,bn)$(0, b_2, \dots, b_n)$ after being hit by his opponent. The velocity components of the ball in each of the n$n$ dimensions are also immediately known to Chef, the component in the ith$i^{th}$ dimension being vi$v_i$. The ball will continue to move with fixed velocity until it leaves Chef's court. The ball is said to leave Chef's court when it reaches a position strictly outside the bounds of Chef's court. Chef is currently at position (c1,c2,…,cn)$(c_1, c_2, \dots, c_n)$. To hit the ball back, Chef must intercept the ball before it leaves his court, which means at a certain time the ball's position and Chef's position must coincide.
To achieve this, Chef is free to change his speed and direction at any time starting from time t=0$t=0$. However, Chef is lazy so he does not want to put in more effort than necessary. Chef wants to minimize the maximum speed that he needs to acquire at any point in time until he hits the ball. Find this minimum value of speed smin$s_{min}$.
Note: If an object moves with fixed velocity →v$\vec{v}$ and is at position →x$\vec{x}$ at time 0$0$, its position at time t$t$ is given by →x+→v⋅t$\vec{x} + \vec{v} \cdot t$.
-----Input-----
- The first line contains t$t$, the number of test cases. t$t$ cases follow.
- The first line of each test case contains n$n$, the number of dimensions.
- The next line contains n$n$ integers l1,l2,…,ln$l_1, l_2, \dots, l_n$, the bounds of Chef's court.
- The next line contains n$n$ integers b1,b2,…,bn$b_1, b_2, \dots, b_n$, the position of the ball at t=0$t=0$.
- The next line contains n$n$ integers v1,v2,…,vn$v_1, v_2, \dots, v_n$, the velocity components of the ball.
- The next line contains n$n$ integers, c1,c2,…,cn$c_1, c_2, \dots, c_n$, Chef's position at t=0$t=0$.
-----Output-----
- For each test case, output a single line containing the value of smin$s_{min}$. Your answer will be considered correct if the absolute error does not exceed 10−2$10^{-2}$.
-----Constraints-----
- 1≤t≤1500$1 \leq t \leq 1500$
- 2≤n≤50$2 \leq n \leq 50$
- 1≤li≤50$1 \leq l_i \leq 50$
- 0≤bi≤li$0 \leq b_i \leq l_i$ and b1=0$b_1 = 0$
- −10≤vi≤10$-10 \leq v_i \leq 10$ and v1>0$v_1 > 0$
- 0≤ci≤li$0 \leq c_i \leq l_i$
- It is guaranteed that the ball stays in the court for a non-zero amount of time.
-----Sample Input-----
2
2
3 4
0 2
2 -2
2 2
3
10 10 10
0 0 0
1 1 1
5 5 5
-----Sample Output-----
2.0000
0.0000
-----Explanation-----
Case 1: The court is 2-dimentional.
The ball's trajectory is marked in red. For Chef it is optimal to move along the blue line at a constant speed of 2 until he meets the ball at the boundary.
Case 2: The court is 3-dimensional and the ball is coming straight at Chef. So it is best for Chef to not move at all, thus smin=0$s_{min} = 0$.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
eps=1e-8
t=int(input())
for ii in range(t):
n=int(input())
l=[int(i) for i in input().split() ]
b=[int(i) for i in input().split() ]
v=[int(i) for i in input().split() ]
c=[int(i) for i in input().split() ]
greatest_time=l[0]/v[0]
for i in range(1,n):
if v[i]>0:
greatest_time=min(greatest_time,(l[i]-b[i])/v[i])
elif v[i]<0:
greatest_time=min(greatest_time,-b[i]/v[i])
p = sum((b[i] - c[i]) ** 2 for i in range(n))
q = sum(2 * (b[i] - c[i]) * v[i] for i in range(n))
r = sum(vi ** 2 for vi in v)
func = lambda t: p/t/t + q/t + r
#ternary search
def ternsearch():
if b==c:
return(0)
lo,hi=0,greatest_time
while hi-lo>eps:
d=(hi-lo)/3
m1=lo+d
m2=m1+d
if func(m1)<=func(m2):
hi=m2
else:
lo=m1
#print(hi,lo)
#print(func(lo)**(0.5))
return max(0,func(lo))**(0.5)
ans=ternsearch()
print('%.12f' % (ans,))
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Chef changed the password of his laptop a few days ago, but he can't remember it today. Luckily, he wrote the encrypted password on a piece of paper, along with the rules for decryption.
The encrypted password is a string S consists of ASCII printable characters except space (ASCII 33 - 126, in decimal notation, the same below). Read here for more details: ASCII printable characters.
Each rule contains a pair of characters ci, pi, denoting that every character ci appears in the encrypted password should be replaced with pi. Notice that it is not allowed to do multiple replacements on a single position, see example case 1 for clarification.
After all the character replacements, the string is guaranteed to be a positive decimal number. The shortest notation of this number is the real password. To get the shortest notation, we should delete all the unnecessary leading and trailing zeros. If the number contains only non-zero fractional part, the integral part should be omitted (the shortest notation of "0.5" is ".5"). If the number contains zero fractional part, the decimal point should be omitted as well (the shortest notation of "5.00" is "5").
Please help Chef to find the real password.
-----Input-----
The first line of the input contains an interger T denoting the number of test cases.
The description of T test cases follows.
The first line of each test case contains a single interger N, denoting the number of rules.
Each of the next N lines contains two space-separated characters ci and pi,
denoting a rule.
The next line contains a string S, denoting the encrypted password.
-----Output-----
For each test case, output a single line containing the real password.
-----Constraints-----
- 1 ≤ T ≤ 1000
- 0 ≤ N ≤ 94
- All characters in S and ci may be any ASCII printable character except space. (ASCII 33 - 126)
- All ci in a single test case are distinct.
- pi is a digit ("0" - "9") or a decimal point "." (ASCII 46).
- The total length of S in a single input file will not exceed 106.
-----Example-----
Input:
4
2
5 3
3 1
5
0
01800.00
0
0.00100
3
x 0
d 3
# .
0xd21#dd098x
Output:
3
1800
.001
321.33098
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
from decimal import Decimal
T = int(input())
for _ in range(T):
N = int(input())
data = dict()
for __ in range(N):
ci, pi = input().split()
data[ci] = pi
S = list(input())
for i in range(len(S)):
if S[i] in data.keys():
S[i] = data[S[i]]
###
S = "".join(S)
if '.' in S:
S = S.strip('0').rstrip('.')
else:
S = S.lstrip('0')
print(S or '0')
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
You are given n strings s_1, s_2, ..., s_{n} consisting of characters 0 and 1. m operations are performed, on each of them you concatenate two existing strings into a new one. On the i-th operation the concatenation s_{a}_{i}s_{b}_{i} is saved into a new string s_{n} + i (the operations are numbered starting from 1). After each operation you need to find the maximum positive integer k such that all possible strings consisting of 0 and 1 of length k (there are 2^{k} such strings) are substrings of the new string. If there is no such k, print 0.
-----Input-----
The first line contains single integer n (1 ≤ n ≤ 100) — the number of strings. The next n lines contain strings s_1, s_2, ..., s_{n} (1 ≤ |s_{i}| ≤ 100), one per line. The total length of strings is not greater than 100.
The next line contains single integer m (1 ≤ m ≤ 100) — the number of operations. m lines follow, each of them contains two integers a_{i} abd b_{i} (1 ≤ a_{i}, b_{i} ≤ n + i - 1) — the number of strings that are concatenated to form s_{n} + i.
-----Output-----
Print m lines, each should contain one integer — the answer to the question after the corresponding operation.
-----Example-----
Input
5
01
10
101
11111
0
3
1 2
6 5
4 4
Output
1
2
0
-----Note-----
On the first operation, a new string "0110" is created. For k = 1 the two possible binary strings of length k are "0" and "1", they are substrings of the new string. For k = 2 and greater there exist strings of length k that do not appear in this string (for k = 2 such string is "00"). So the answer is 1.
On the second operation the string "01100" is created. Now all strings of length k = 2 are present.
On the third operation the string "1111111111" is created. There is no zero, so the answer is 0.
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, stdout
K = 20
def findAllStrings(s):
n = len(s)
sDict = {}
for i in range(1,K+1):
sDict[i]=set()
for x in range(n-i+1):
sDict[i].add(s[x:x+i])
return sDict
n = int(stdin.readline().rstrip())
stringDicts = []
stringEnd = []
stringBegin = []
for i in range(n):
s = stdin.readline().rstrip()
stringDicts.append(findAllStrings(s))
if len(s)<K:
stringEnd.append(s)
stringBegin.append(s)
else:
stringEnd.append(s[-20:])
stringBegin.append(s[:20])
m = int(stdin.readline().rstrip())
for _ in range(m):
a,b = list(map(int,stdin.readline().rstrip().split()))
a-=1
b-=1
sDict1 = findAllStrings(stringEnd[a]+stringBegin[b])
sDict2 = stringDicts[a]
sDict3 = stringDicts[b]
sDict={}
for i in range(1,K+1):
sDict[i] = sDict1[i]|sDict2[i]|sDict3[i]
stringDicts.append(sDict)
for i in range(1,K+1):
if len(sDict[i])!=2**i:
print(i-1)
break
if len(stringBegin[a])<K and len(stringBegin[a])+len(stringBegin[b])<K:
stringBegin.append(stringBegin[a]+stringBegin[b])
elif len(stringBegin[a])<K:
s = stringBegin[a]+stringBegin[b]
stringBegin.append(s[:K])
else:
stringBegin.append(stringBegin[a])
if len(stringEnd[b])<K and len(stringEnd[a])+len(stringEnd[b])<K:
stringEnd.append(stringEnd[a]+stringEnd[b])
elif len(stringEnd[b])<K:
s = stringEnd[a]+stringEnd[b]
stringEnd.append(s[-K:])
else:
stringEnd.append(stringEnd[b])
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Ada's classroom contains $N \cdot M$ tables distributed in a grid with $N$ rows and $M$ columns. Each table is occupied by exactly one student.
Before starting the class, the teacher decided to shuffle the students a bit. After the shuffling, each table should be occupied by exactly one student again. In addition, each student should occupy a table that is adjacent to that student's original table, i.e. immediately to the left, right, top or bottom of that table.
Is it possible for the students to shuffle while satisfying all conditions of the teacher?
-----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 the string "YES" if it is possible to satisfy the conditions of the teacher or "NO" otherwise (without quotes).
-----Constraints-----
- $1 \le T \le 5,000$
- $2 \le N, M \le 50$
-----Example Input-----
2
3 3
4 4
-----Example Output-----
NO
YES
-----Explanation-----
Example case 2: The arrows in the following image depict how the students moved.
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 _ in range(t):
N, M=map(int,input().split())
if(N%2==0 or M%2==0):
print("YES")
else:
print("NO")
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Chef and his girlfriend are going to have a promenade. They are walking along the straight road which consists of segments placed one by one. Before walking Chef and his girlfriend stay at the beginning of the first segment, they want to achieve the end of the last segment.
There are few problems:
- At the beginning Chef should choose constant integer - the velocity of mooving. It can't be changed inside one segment.
- The velocity should be decreased by at least 1 after achieving the end of some segment.
- There is exactly one shop on each segment. Each shop has an attractiveness. If it's attractiveness is W and Chef and his girlfriend move with velocity V then if V < W girlfriend will run away into the shop and the promenade will become ruined.
Chef doesn't want to lose her girl in such a way, but he is an old one, so you should find the minimal possible velocity at the first segment to satisfy all conditions.
-----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 a single integer N denoting the number of segments. The second line contains N space-separated integers W1, W2, ..., WN denoting the attractiveness of shops.
-----Output-----
- For each test case, output a single line containing the minimal possible velocity at the beginning.
-----Constraints-----
- 1 ≤ T ≤ 10
- 1 ≤ N ≤ 10^5
- 1 ≤ Wi ≤ 10^6
-----Example-----
Input:
2
5
6 5 4 3 2
5
3 4 3 1 1
Output:
6
5
-----Explanation-----
Example case 1.
If we choose velocity 6, on the first step we have 6 >= 6 everything is OK, then we should decrease the velocity to 5 and on the 2nd segment we'll receive 5 >= 5, again OK, and so on.
Example case 2.
If we choose velocity 4, the promanade will be ruined on the 2nd step (we sould decrease our velocity, so the maximal possible will be 3 which is less than 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 i in range(T):
x = int(input())
l= [int(x) for x in input().split()]
t=[]
for i in range(len(l)):
t.append(l[i]+i)
print(max(t))
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
There are N barbecue restaurants along a street.
The restaurants are numbered 1 through N from west to east, and the distance between restaurant i and restaurant i+1 is A_i.
Joisino has M tickets, numbered 1 through M.
Every barbecue restaurant offers barbecue meals in exchange for these tickets.
Restaurant i offers a meal of deliciousness B_{i,j} in exchange for ticket j.
Each ticket can only be used once, but any number of tickets can be used at a restaurant.
Joisino wants to have M barbecue meals by starting from a restaurant of her choice, then repeatedly traveling to another barbecue restaurant and using unused tickets at the restaurant at her current location.
Her eventual happiness is calculated by the following formula: "(The total deliciousness of the meals eaten) - (The total distance traveled)".
Find her maximum possible eventual happiness.
-----Constraints-----
- All input values are integers.
- 2≤N≤5×10^3
- 1≤M≤200
- 1≤A_i≤10^9
- 1≤B_{i,j}≤10^9
-----Input-----
The input is given from Standard Input in the following format:
N M
A_1 A_2 ... A_{N-1}
B_{1,1} B_{1,2} ... B_{1,M}
B_{2,1} B_{2,2} ... B_{2,M}
:
B_{N,1} B_{N,2} ... B_{N,M}
-----Output-----
Print Joisino's maximum possible eventual happiness.
-----Sample Input-----
3 4
1 4
2 2 5 1
1 3 3 2
2 2 5 1
-----Sample Output-----
11
The eventual happiness can be maximized by the following strategy: start from restaurant 1 and use tickets 1 and 3, then move to restaurant 2 and use tickets 2 and 4.
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
from array import array
input = sys.stdin.readline
class Bit:
def __init__(self, n):
self.size = n
self.size_bit_length = n.bit_length()
self.tree = array('h', [0] * (n+1))
def reset(self):
self.tree = array('h', [0] * (self.size+1))
def sum(self, i):
s = 0
while i > 0:
s += self.tree[i]
i -= i & -i
return s
def add(self, i, x):
while i <= self.size:
self.tree[i] += x
i += i & -i
def lower_bound(self, w):
if w <= 0:
return 0
x = 0
k = 1 << (self.size_bit_length - 1)
while k:
if x + k <= self.size and self.tree[x + k] < w:
w -= self.tree[x + k]
x += k
k >>= 1
return x + 1
N, M = list(map(int, input().split()))
dist = [0] + list(map(int, input().split()))
for i in range(N-1):
dist[i+1] += dist[i]
B = [0] * (M * N)
for i in range(N):
BB = list(map(int, input().split()))
for j in range(M):
B[j * N + i] = BB[j] * (N+1) + i+1
imos = []
for i in range(N+1):
imos.append([0] * (N+1 - i))
bit = Bit(N)
for m in range(M):
bit.reset()
for bi in sorted(B[m*N: (m+1) * N], reverse=True):
b, i = divmod(bi, N+1)
k = bit.sum(i)
l = bit.lower_bound(k)
r = bit.lower_bound(k+1)
imos[l+1][i - (l+1)] += b
if i != N:
imos[i+1][0] -= b
if r != N+1:
imos[l+1][r - (l+1)] -= b
if i != N and r != N+1:
imos[i+1][r - (i+1)] += b
bit.add(i, 1)
for i in range(1, N+1):
for j in range(i+1, N+1):
imos[i][j - i] += imos[i][j-1-i]
for i in range(2, N + 1):
for j in range(i, N + 1):
imos[i][j-i] += imos[i - 1][j - (i-1)]
ans = 0
for i in range(1, N + 1):
for j in range(i, N + 1):
ans = max(ans, imos[i][j-i] - (dist[j - 1] - dist[i - 1]))
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:
In order to establish dominance amongst his friends, Chef has decided that he will only walk in large steps of length exactly $K$ feet. However, this has presented many problems in Chef’s life because there are certain distances that he cannot traverse. Eg. If his step length is $5$ feet, he cannot travel a distance of $12$ feet. Chef has a strict travel plan that he follows on most days, but now he is worried that some of those distances may become impossible to travel. Given $N$ distances, tell Chef which ones he cannot travel.
-----Input:-----
- The first line will contain a single integer $T$, the number of test cases.
- The first line of each test case will contain two space separated integers - $N$, the number of distances, and $K$, Chef’s step length.
- The second line of each test case will contain $N$ space separated integers, the $i^{th}$ of which represents $D_i$, the distance of the $i^{th}$ path.
-----Output:-----
For each testcase, output a string consisting of $N$ characters. The $i^{th}$ character should be $1$ if the distance is traversable, and $0$ if not.
-----Constraints-----
- $1 \leq T \leq 1000$
- $1 \leq N \leq 1000$
- $1 \leq K \leq 10^9$
- $1 \leq D_i \leq 10^9$
-----Subtasks-----
- 100 points : No additional constraints.
-----Sample Input:-----
1
5 3
12 13 18 20 27216
-----Sample Output:-----
10101
-----Explanation:-----
The first distance can be traversed in $4$ steps.
The second distance cannot be traversed.
The third distance can be traversed in $6$ steps.
The fourth distance cannot be traversed.
The fifth distance can be traversed in $9072$ steps.
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(0,t):
n,k=map(int,input().split())
a1,*a=map(int,input().split())
a.insert(0,a1)
j=0
while j<n:
if a[j]%k==0:
print(1,end="")
else:
print(0,end="")
j+=1
print("")
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Gru wants to distribute $N$ bananas to $K$ minions on his birthday.
Gru does not like to just give everyone the same number of bananas, so instead, he wants to distribute bananas in such a way that each minion gets a $distinct$ amount of bananas. That is, no two minions should get the same number of bananas.
Gru also loves $gcd$. The higher the $gcd$, the happier Gru and the minions get. So help Gru in distributing the bananas in such a way that each Minion gets a distinct amount of bananas and gcd of this distribution is highest possible. Output this maximum gcd. If such a distribution is not possible output $-1$.
Note: You have to distribute $all$ $N$ bananas.
-----Input:-----
- First line will contain $T$, number of testcases. Then the testcases follow.
- Each testcase consists of a single line of input, which has two integers: $N, K$.
-----Output:-----
For each testcase, output in a single line the maximum gcd or -1.
-----Constraints-----
- $1 \leq T \leq 100$
- $1 \leq N, K \leq 10^9$
-----Sample Input:-----
1
6 3
-----Sample Output:-----
1
-----EXPLANATION:-----
The only possible distribution is $[1, 2, 3]$. 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 math import sqrt
for _ in range(int(input())):
n, k = map(int, input().split())
fact,i = [],1
while i<=sqrt(n):
if n%i==0:
if (n // i != i):
fact.append(n//i)
fact.append(i)
i+=1
tot = (k*(k+1))//2
mx = -1
for i in fact:
if i>=tot:
mx = max(mx,n//i)
print(mx)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
There is a big staircase with $N$ steps (numbered $1$ through $N$) in ChefLand. Let's denote the height of the top of step $i$ by $h_i$. Chef Ada is currently under the staircase at height $0$ and she wants to reach the top of the staircase (the top of the last step). However, she can only jump from height $h_i$ to the top of a step at height $h_f$ if $h_f-h_i \le K$. To help Ada, we are going to construct some intermediate steps; each of them may be constructed between any two steps, or before the first step, and have any height. What is the minimum number of steps that need to be added to the staircase so that Ada could reach the top?
-----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 $N$ space-seperated integers $h_1, h_2, \dots, h_N$.
-----Output-----
For each test case, print a single line containing one integer — the minimum required number of steps.
-----Constraints-----
- $1 \le T \le 64$
- $1 \le N \le 128$
- $1 \le K \le 1,024$
- $1 \le h_i \le 1,024$ for each valid $i$
- $h_i < h_{i+1}$ for each valid $i$
-----Example Input-----
1
4 3
2 4 8 16
-----Example Output-----
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
import numpy as np
def minstairs(n,k):
stairsHeight=[]
stairs=0
current = 0
stairsHeight=list(map(int, input().split()))
stairsHeight=np.array(stairsHeight)
curr=0
for i in range(n):
if stairsHeight[i]-curr<=k:
curr=stairsHeight[i]
else:
if (stairsHeight[i]-curr)%k==0:
stairs+=((stairsHeight[i]-curr)//k)-1
else:
stairs+=(stairsHeight[i]-curr)//k
curr=stairsHeight[i]
return stairs
T=int(input())
for i in range(T):
n,k =list(map(int,input().split()))
print(minstairs(n,k))
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Chef Two and Chef Ten are playing a game with a number $X$. In one turn, they can multiply $X$ by $2$. The goal of the game is to make $X$ divisible by $10$.
Help the Chefs find the smallest number of turns necessary to win the game (it may be possible to win in zero turns) or determine that it is impossible.
-----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 denoting the initial value of $X$.
-----Output-----
For each test case, print a single line containing one integer — the minimum required number of turns or $-1$ if there is no way to win the game.
-----Constraints-----
- $1 \le T \le 1000$
- $0 \le X \le 10^9$
-----Subtasks-----
Subtask #1 (100 points): original constraints
-----Example Input-----
3
10
25
1
-----Example Output-----
0
1
-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
t=int(input())
for i in range(t):
x=int(input())
if x%10==0:
print(0)
elif x%5==0:
print(1)
else:
print(-1)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
There is a universal library, where there is a big waiting room with seating capacity for maximum $m$ people, each of whom completes reading $n$ books sequentially. Reading each book requires one unit of time.
Unfortunately, reading service is provided sequentially. After all of the $m$ people enter the library, the entrance gate is closed. There is only one reading table. So when someone reads, others have to wait in the waiting room.
At first everybody chooses $n$ books they want to read. It takes $x$ amount of time. People can choose books simultaneously. Then they enter the waiting room. After reading $n$ books the person leaves the library immediately.
As nothing is free, the cost of reading is also not free. If a person stays in the library $t$ units of time then the cost of reading is $\left \lfloor \frac{t-n}{m} \right \rfloor$ units of money. So, the $i^{th}$ person pays for time $x$ he needs to choose books and the time $(i-1)*n$ he needs to wait for all the persons before him to complete reading.
Note: $\left \lfloor a \right \rfloor$ denotes the floor($a$).
-----Input-----
- Each case contains three space-separated positive integers $n$, $m$ and $x$ where $n, x \leq 1000$ and $m \leq 10^{15}$.
- End of input is determined by three zeros.
- There are no more than 1000 test cases.
-----Output-----
- For each case, output in a single line the total unit of money the library gets in that day.
-----Sample Input-----
1 100 9
11 2 10
12 2 11
0 0 0
-----Sample Output-----
9
15
16
-----Explanation:-----
Testcase 2: Here, $n=11$, $m=2$, $x=10$.
For 1st person,
$t=21$ and he/she gives $\left \lfloor \frac{21-11}{2} \right \rfloor = 5$ units of money.
For 2nd person,
$t=32$ and he/she gives $\left \lfloor \frac{32-11}{2} \right \rfloor= 10$ units of money.
So, total units of money $= 5+10 = 15$
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
while(True):
n, m, x = map(int, input().split())
if(n==0 and m==0 and x==0):
break
money=0
for i in range(n):
money=money + (x+m*i)//n
print(money)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
The Duck song
For simplicity, we'll assume that there are only three types of grapes: green grapes, purple grapes and black grapes.
Andrew, Dmitry and Michal are all grapes' lovers, however their preferences of grapes are different. To make all of them happy, the following should happen: Andrew, Dmitry and Michal should eat at least $x$, $y$ and $z$ grapes, respectively. Andrew has an extreme affinity for green grapes, thus he will eat green grapes and green grapes only. On the other hand, Dmitry is not a fan of black grapes — any types of grapes except black would do for him. In other words, Dmitry can eat green and purple grapes. Michal has a common taste — he enjoys grapes in general and will be pleased with any types of grapes, as long as the quantity is sufficient.
Knowing that his friends are so fond of grapes, Aki decided to host a grape party with them. He has prepared a box with $a$ green grapes, $b$ purple grapes and $c$ black grapes.
However, Aki isn't sure if the box he prepared contains enough grapes to make everyone happy. Can you please find out whether it's possible to distribute grapes so that everyone is happy or Aki has to buy some more grapes?
It is not required to distribute all the grapes, so it's possible that some of them will remain unused.
-----Input-----
The first line contains three integers $x$, $y$ and $z$ ($1 \le x, y, z \le 10^5$) — the number of grapes Andrew, Dmitry and Michal want to eat.
The second line contains three integers $a$, $b$, $c$ ($1 \le a, b, c \le 10^5$) — the number of green, purple and black grapes in the box.
-----Output-----
If there is a grape distribution that allows everyone to be happy, print "YES", otherwise print "NO".
-----Examples-----
Input
1 6 2
4 3 3
Output
YES
Input
5 1 1
4 3 2
Output
NO
-----Note-----
In the first example, there is only one possible distribution:
Andrew should take $1$ green grape, Dmitry should take $3$ remaining green grapes and $3$ purple grapes, and Michal will take $2$ out of $3$ available black grapes.
In the second test, there is no possible distribution, since Andrew is not be able to eat enough green grapes. :(
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
x,y,z = list(map(int,input().split()))
a,b,c = list(map(int,input().split()))
if a < x:
print("NO")
return
x -= a
y += x
if b < y:
print("NO")
return
y -= b
z += y
if c < z:
print("NO")
return
print("YES")
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Chef has $N$ doggo (dogs) , Lets number them $1$ to $N$.
Chef decided to build houses for each, but he soon realizes that keeping so many dogs at one place may be messy. So he decided to divide them into several groups called doggo communities. Let the total no. of groups be $K$ . In a community, paths between pairs of houses can be made so that doggo can play with each other. But there cannot be a path between two houses of different communities for sure. Chef wanted to make maximum no. of paths such that the total path is not greater then $K$.
Let’s visualize this problem in an engineer's way :)
The problem is to design a graph with max edge possible such that the total no. of edges should not be greater than the total no. of connected components.
-----INPUT FORMAT-----
- First line of each test case file contain $T$ , denoting total number of test cases.
- $ith$ test case contain only one line with a single integer $N$ , denoting the number of dogs(vertex)
-----OUTPUT FORMAT-----
- For each test case print a line with a integer , denoting the maximum possible path possible.
-----Constraints-----
- $1 \leq T \leq 10000$
- $1 \leq N \leq 10^9$
-----Sub-Tasks-----
- $20 Points$
- $1 \leq N \leq 10^6$
-----Sample Input-----
1
4
-----Sample Output-----
2
-----Explanation-----
4 houses can be made with like this:
community #1 : [1 - 2 ]
community #2 : [3 - 4 ]
or [1 - 2 - 3] , [ 4 ]
In both cases the maximum possible path is 2.
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
import sys
def get_array(): return list(map(int , sys.stdin.readline().strip().split()))
def get_ints(): return list(map(int, sys.stdin.readline().strip().split()))
def input(): return sys.stdin.readline().strip()
import math
from collections import defaultdict
from itertools import combinations_with_replacement,permutations
import bisect
import math as mt
from functools import reduce
import time
def __starting_point():
for _ in range(int(input())):
n = int(input())
a=1
b=1
c=(-2*n)
dis = b * b - 4 * a * c
sqrt_val = math.sqrt(abs(dis))
r1=(-b + sqrt_val)/(2 * a)
# r2=(-b - sqrt_val)/(2 * a)
# print(r1)
r1 = math.floor(r1)+1
print(n-r1+1)
__starting_point()
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
You stumbled upon a new kind of chess puzzles. The chessboard you are given is not necesserily $8 \times 8$, but it still is $N \times N$. Each square has some number written on it, all the numbers are from $1$ to $N^2$ and all the numbers are pairwise distinct. The $j$-th square in the $i$-th row has a number $A_{ij}$ written on it.
In your chess set you have only three pieces: a knight, a bishop and a rook. At first, you put one of them on the square with the number $1$ (you can choose which one). Then you want to reach square $2$ (possibly passing through some other squares in process), then square $3$ and so on until you reach square $N^2$. In one step you are allowed to either make a valid move with the current piece or replace it with some other piece. Each square can be visited arbitrary number of times.
A knight can move to a square that is two squares away horizontally and one square vertically, or two squares vertically and one square horizontally. A bishop moves diagonally. A rook moves horizontally or vertically. The move should be performed to a different square from the one a piece is currently standing on.
You want to minimize the number of steps of the whole traversal. Among all the paths to have the same number of steps you want to choose the one with the lowest number of piece replacements.
What is the path you should take to satisfy all conditions?
-----Input-----
The first line contains a single integer $N$ ($3 \le N \le 10$) — the size of the chessboard.
Each of the next $N$ lines contains $N$ integers $A_{i1}, A_{i2}, \dots, A_{iN}$ ($1 \le A_{ij} \le N^2$) — the numbers written on the squares of the $i$-th row of the board.
It is guaranteed that all $A_{ij}$ are pairwise distinct.
-----Output-----
The only line should contain two integers — the number of steps in the best answer and the number of replacement moves in it.
-----Example-----
Input
3
1 9 3
8 6 7
4 2 5
Output
12 1
-----Note-----
Here are the steps for the first example (the starting piece is a knight): Move to $(3, 2)$ Move to $(1, 3)$ Move to $(3, 2)$ Replace the knight with a rook Move to $(3, 1)$ Move to $(3, 3)$ Move to $(3, 2)$ Move to $(2, 2)$ Move to $(2, 3)$ Move to $(2, 1)$ Move to $(1, 1)$ Move to $(1, 2)$
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())
graph=[{},{},{}]
for i in range(n):
for j in range(n):
graph[0][(i,j)]=[(k,j) for k in range(n)]+[(i,k) for k in range(n)]
graph[0][(i,j)].remove((i,j))
graph[0][(i,j)].remove((i,j))
graph[1][(i,j)]=[]
for k in range(n):
for l in range(n):
if abs(k-i)==abs(l-j)!=0:
graph[1][(i,j)].append((k,l))
graph[2][(i,j)]=[]
for k in range(n):
for l in range(n):
if {abs(k-i),abs(l-j)}=={1,2}:
graph[2][(i,j)].append((k,l))
dists=[[{},{},{}],[{},{},{}],[{},{},{}]]
for i in range(n):
for j in range(n):
for k in range(3):
dists[k][k][(i,j,i,j)]=0
for i in range(n):
for j in range(n):
for k in range(3):
layers=[[(i,j,k,0)],[],[],[],[]]
for l in range(4):
for guy in layers[l]:
for m in range(3):
if m!=guy[2]:
if (i,j,guy[0],guy[1]) not in dists[k][m]:
layers[l+1].append((guy[0],guy[1],m,guy[3]+1))
dists[k][m][(i,j,guy[0],guy[1])]=1000*(l+1)+guy[3]+1
for boi in graph[guy[2]][(guy[0],guy[1])]:
if (i,j,boi[0],boi[1]) not in dists[k][guy[2]]:
layers[l+1].append((boi[0],boi[1],guy[2],guy[3]))
dists[k][guy[2]][(i,j,boi[0],boi[1])]=1000*(l+1)+guy[3]
elif 1000*(l+1)+guy[3]<dists[k][guy[2]][(i,j,boi[0],boi[1])]:
layers[l+1].append((boi[0],boi[1],guy[2],guy[3]))
dists[k][guy[2]][(i,j,boi[0],boi[1])]=1000*(l+1)+guy[3]
locs=[None]*(n**2)
for i in range(n):
a=list(map(int,input().split()))
for j in range(n):
locs[a[j]-1]=(i,j)
best=(0,0,0)
for i in range(n**2-1):
tup=(locs[i][0],locs[i][1],locs[i+1][0],locs[i+1][1])
new0=min(best[0]+dists[0][0][tup],best[1]+dists[1][0][tup],best[2]+dists[2][0][tup])
new1=min(best[0]+dists[0][1][tup],best[1]+dists[1][1][tup],best[2]+dists[2][1][tup])
new2=min(best[0]+dists[0][2][tup],best[1]+dists[1][2][tup],best[2]+dists[2][2][tup])
best=(new0,new1,new2)
a=min(best)
print(a//1000,a%1000)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
The Chef has one long loaf of bread of length 1. He wants to cut it into as many little loaves as he can. But he wants to adhere to the following rule: At any moment, the length of the longest loaf which he possesses may not be larger than the length of shortest one, times some constant factor. Every time, he is only allowed to cut exactly one loaf into two shorter ones.
-----Input-----
One floating-point number, 1 ≤ k ≤ 1.999, meaning the stated constant factor. The number will have at most 3 digits after the decimal point.
-----Output-----
First, you should output one number n, the maximal achievable number of loaves for the given value of the constant factor. Then, you should output any proof that this number of loaves is in fact achievable: n-1 descriptions of cutting, using the following notation. At each step, you print two numbers: first, the index of the loaf that you want to cut into two parts; second, the length of the newly created loaf (cut off from the original one). It is assumed that the starting loaf has index 0. Each newly created loaf will be given the lowest possible free integer index (so, at the ith step this will be i). Each time, the size of size of the original loaf will be decreased by the size of the newly created loaf.
-----Example-----
Input:
1.5
Output:
4
0 0.4
0 0.3
1 0.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
from math import log
k = float(sys.stdin.readline())
answer = int(log(2.0, 2.0/k))
print(2*answer)
m = 2 ** (1.0/answer)
# m = 2.0/k
thesum = 0
for i in range(answer):
thesum += m**i
# print [m**i/thesum for i in xrange(answer)]
loaves = [1]
def maxIndex(list):
max = -1
mi = -1
for i, x in enumerate(list):
if x > max:
max = x
mi = i
return mi
desired = [m**i/thesum for i in range(answer)]
desired.reverse()
# print desired
cuts = []
while len(desired) > 1:
cuts.append(desired[-1])
lastsum = desired[-1] + desired[-2]
del desired[-2:]
desired[0:0] = [lastsum]
# print cuts
while cuts:
length = cuts.pop()
i = maxIndex(loaves)
print(i, length)
loaves[i] -= length
loaves.append(length)
# print loaves
# print loaves
for i in range(answer):
i = maxIndex(loaves[:answer])
x = loaves[i]/2.0
print(i, x)
loaves.append(x)
loaves[i] -= x
# print loaves
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Chef wants to buy a new phone, but he is not willing to spend a lot of money. Instead, he checks the price of his chosen model everyday and waits for the price to drop to an acceptable value. So far, he has observed the price for $N$ days (numbere $1$ through $N$); for each valid $i$, the price on the $i$-th day was $P_i$ dollars.
On each day, Chef considers the price of the phone to be good if it is strictly smaller than all the prices he has observed during the previous five days. If there is no record of the price on some of the previous five days (because Chef has not started checking the price on that day yet), then Chef simply ignores that previous day ― we could say that he considers the price on that day to be infinite.
Now, Chef is wondering ― on how many days has he considered the price to be good? Find the number of these days.
-----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 $P_1, P_2, \dots, P_N$.
-----Output-----
For each test case, print a single line containing one integer ― the number of days with a good price.
-----Constraints-----
- $1 \le T \le 100$
- $7 \le N \le 100$
- $350 \le P_i \le 750$ for each valid $i$
-----Subtasks-----
Subtask #1 (30 points): $N = 7$
Subtask #2 (70 points): original constraints
-----Example Input-----
1
7
375 750 723 662 647 656 619
-----Example Output-----
2
-----Explanation-----
Example case 1: Chef considers the price to be good on day $1$, because he has not observed any prices on the previous days. The prices on days $2, 3, 4, 5, 6$ are not considered good because they are greater than the price on day $1$. Finally, the price on day $7$ is considered good because it is smaller than all of the prices on days $2, 3, 4, 5, 6$.
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=int(input())
a=list(map(int,input().split()))
g=1
for j in range(1,n):
if j-5<0:
mi=min(a[0:j])
#print(a[0:j])
if mi>a[j]:
g=g+1
else:
mi=min(a[j-5:j])
#print(a[j-5:j])
if mi>a[j]:
g=g+1
print(g)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Polycarp plays a computer game (yet again). In this game, he fights monsters using magic spells.
There are two types of spells: fire spell of power $x$ deals $x$ damage to the monster, and lightning spell of power $y$ deals $y$ damage to the monster and doubles the damage of the next spell Polycarp casts. Each spell can be cast only once per battle, but Polycarp can cast them in any order.
For example, suppose that Polycarp knows three spells: a fire spell of power $5$, a lightning spell of power $1$, and a lightning spell of power $8$. There are $6$ ways to choose the order in which he casts the spells:
first, second, third. This order deals $5 + 1 + 2 \cdot 8 = 22$ damage; first, third, second. This order deals $5 + 8 + 2 \cdot 1 = 15$ damage; second, first, third. This order deals $1 + 2 \cdot 5 + 8 = 19$ damage; second, third, first. This order deals $1 + 2 \cdot 8 + 2 \cdot 5 = 27$ damage; third, first, second. This order deals $8 + 2 \cdot 5 + 1 = 19$ damage; third, second, first. This order deals $8 + 2 \cdot 1 + 2 \cdot 5 = 20$ damage.
Initially, Polycarp knows $0$ spells. His spell set changes $n$ times, each time he either learns a new spell or forgets an already known one. After each change, calculate the maximum possible damage Polycarp may deal using the spells he knows.
-----Input-----
The first line contains one integer $n$ ($1 \le n \le 2 \cdot 10^5$) — the number of changes to the spell set.
Each of the next $n$ lines contains two integers $tp$ and $d$ ($0 \le tp_i \le 1$; $-10^9 \le d \le 10^9$; $d_i \neq 0$) — the description of the change. If $tp_i$ if equal to $0$, then Polycarp learns (or forgets) a fire spell, otherwise he learns (or forgets) a lightning spell.
If $d_i > 0$, then Polycarp learns a spell of power $d_i$. Otherwise, Polycarp forgets a spell with power $-d_i$, and it is guaranteed that he knew that spell before the change.
It is guaranteed that the powers of all spells Polycarp knows after each change are different (Polycarp never knows two spells with the same power).
-----Output-----
After each change, print the maximum damage Polycarp can deal with his current set of spells.
-----Example-----
Input
6
1 5
0 10
1 -5
0 5
1 11
0 -10
Output
5
25
10
15
36
21
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,heapq,random
input=sys.stdin.readline
n=int(input())
spell=[tuple(map(int,input().split())) for i in range(n)]
S=set([])
for i in range(n):
S.add(abs(spell[i][1]))
S=list(S)
S.sort(reverse=True)
comp={i:e+1 for e,i in enumerate(S)}
N=len(S)
x_exist=BIT(N)
y_exist=BIT(N)
power=BIT(N)
X,Y,S=0,0,0
Xmax=[]
Ymin=[]
x_data=[0]*(N+1)
y_data=[0]*(N+1)
for i in range(n):
t,d=spell[i]
S+=d
if d<0:
id=comp[-d]
if t==0:
X-=1
x_exist.update(id,-1)
power.update(id,d)
x_data[id]-=1
else:
Y-=1
y_exist.update(id,-1)
power.update(id,d)
y_data[id]-=1
else:
id=comp[d]
if t==0:
X+=1
x_exist.update(id,1)
power.update(id,d)
heapq.heappush(Xmax,-d)
x_data[id]+=1
else:
Y+=1
y_exist.update(id,1)
power.update(id,d)
heapq.heappush(Ymin,d)
y_data[id]+=1
if X==0:
if Y==0:
print(0)
else:
while not y_data[comp[Ymin[0]]]:
heapq.heappop(Ymin)
print(2*S-Ymin[0])
else:
if Y==0:
print(S)
else:
start=0
end=N
while end-start>1:
test=(end+start)//2
if x_exist.query(test)+y_exist.query(test)<=Y:
start=test
else:
end=test
if y_exist.query(start)!=Y:
print(S+power.query(start))
else:
while not y_data[comp[Ymin[0]]]:
heapq.heappop(Ymin)
while not x_data[comp[-Xmax[0]]]:
heapq.heappop(Xmax)
print(S+power.query(start)-Ymin[0]-Xmax[0])
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Chef and Abhishek both are fighting for the post of Chairperson to be part of ACE committee and are trying their best. To select only one student their teacher gave them a binary string (string consisting of only 0's and 1's) and asked them to find number of sub-strings present in the given string that satisfy the following condition:
The substring should start with 0 and end with 1 or the substring should start with 1 and end with 0 but not start with 0 and end with 0 and start with 1 and end with 1.
More formally, strings such as 100,0101 are allowed since they start and end with different characters. But strings such as 0110,1101 are not allowed because they start and end with same characters.
Both Chef and Abhishek try their best to solve it but couldn't do it. You being a very good friend of Chef, he asks for your help so that he can solve it and become the Chairperson.
-----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 length of the string.
The second line of each test case contains a binary string of length N.
-----Output:-----
For each test case, print a single line containing one integer ― the number of sub strings satisfying above conditions.
-----Constraints-----
- $1 \leq T \leq 1000$
- $2 \leq N \leq 10^9$
Binary string consist's only 0 and 1.
-----Sample Input:-----
1
4
1010
-----Sample Output:-----
4
-----EXPLANATION:-----
All possible substring are : { (1),(0),(1),(0),(10),(01),(10),(101),(010),(1010) }. Out of these only 4 substrings {(10),(01),(10),(1010)} start and end with different characters. Hence the answer 4.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
def countSubstr(str, n, x, y):
tot_count = 0
count_x = 0
for i in range(n):
if str[i] == x:
count_x += 1
if str[i] == y:
tot_count += count_x
return tot_count
t=int(input())
for _ in range(t):
n=int(input())
str=input()
x='0'
y='1'
x1='1'
y1='0'
c1=countSubstr(str,n,x,y)
c2=countSubstr(str,n,x1,y1)
print(c1+c2)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
A number is ternary if it contains only digits $0$, $1$ and $2$. For example, the following numbers are ternary: $1022$, $11$, $21$, $2002$.
You are given a long ternary number $x$. The first (leftmost) digit of $x$ is guaranteed to be $2$, the other digits of $x$ can be $0$, $1$ or $2$.
Let's define the ternary XOR operation $\odot$ of two ternary numbers $a$ and $b$ (both of length $n$) as a number $c = a \odot b$ of length $n$, where $c_i = (a_i + b_i) \% 3$ (where $\%$ is modulo operation). In other words, add the corresponding digits and take the remainders of the sums when divided by $3$. For example, $10222 \odot 11021 = 21210$.
Your task is to find such ternary numbers $a$ and $b$ both of length $n$ and both without leading zeros that $a \odot b = x$ and $max(a, b)$ is the minimum possible.
You have to answer $t$ independent test cases.
-----Input-----
The first line of the input contains one integer $t$ ($1 \le t \le 10^4$) — the number of test cases. Then $t$ test cases follow. The first line of the test case contains one integer $n$ ($1 \le n \le 5 \cdot 10^4$) — the length of $x$. The second line of the test case contains ternary number $x$ consisting of $n$ digits $0, 1$ or $2$. It is guaranteed that the first digit of $x$ is $2$. It is guaranteed that the sum of $n$ over all test cases does not exceed $5 \cdot 10^4$ ($\sum n \le 5 \cdot 10^4$).
-----Output-----
For each test case, print the answer — two ternary integers $a$ and $b$ both of length $n$ and both without leading zeros such that $a \odot b = x$ and $max(a, b)$ is the minimum possible. If there are several answers, you can print any.
-----Example-----
Input
4
5
22222
5
21211
1
2
9
220222021
Output
11111
11111
11000
10211
1
1
110111011
110111010
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=int(input())
s=input()
a=""
b=""
flag=1
for i in s:
if flag:
if i=="2":
a+="1"
b+="1"
elif i=="1":
a+="1"
b+="0"
flag=0
else:
a+="0"
b+="0"
else:
if i=="2":
a+="0"
b+="2"
elif i=="1":
a+="0"
b+="1"
flag=0
else:
a+="0"
b+="0"
print(a)
print(b)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
You are given a string $s$ of even length $n$. String $s$ is binary, in other words, consists only of 0's and 1's.
String $s$ has exactly $\frac{n}{2}$ zeroes and $\frac{n}{2}$ ones ($n$ is even).
In one operation you can reverse any substring of $s$. A substring of a string is a contiguous subsequence of that string.
What is the minimum number of operations you need to make string $s$ alternating? A string is alternating if $s_i \neq s_{i + 1}$ for all $i$. There are two types of alternating strings in general: 01010101... or 10101010...
-----Input-----
The first line contains a single integer $t$ ($1 \le t \le 1000$) — the number of test cases.
The first line of each test case contains a single integer $n$ ($2 \le n \le 10^5$; $n$ is even) — the length of string $s$.
The second line of each test case contains a binary string $s$ of length $n$ ($s_i \in$ {0, 1}). String $s$ has exactly $\frac{n}{2}$ zeroes and $\frac{n}{2}$ ones.
It's guaranteed that the total sum of $n$ over test cases doesn't exceed $10^5$.
-----Output-----
For each test case, print the minimum number of operations to make $s$ alternating.
-----Example-----
Input
3
2
10
4
0110
8
11101000
Output
0
1
2
-----Note-----
In the first test case, string 10 is already alternating.
In the second test case, we can, for example, reverse the last two elements of $s$ and get: 0110 $\rightarrow$ 0101.
In the third test case, we can, for example, make the following two operations: 11101000 $\rightarrow$ 10101100; 10101100 $\rightarrow$ 10101010.
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())
s = input()
ans = 0
for y in range(1, n):
if s[y] == s[y-1]:
ans += 1
print((ans + ans % 2) // 2)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
A group of n cities is connected by a network of roads. There is an undirected road between every pair of cities, so there are $\frac{n \cdot(n - 1)}{2}$ roads in total. It takes exactly y seconds to traverse any single road.
A spanning tree is a set of roads containing exactly n - 1 roads such that it's possible to travel between any two cities using only these roads.
Some spanning tree of the initial network was chosen. For every road in this tree the time one needs to traverse this road was changed from y to x seconds. Note that it's not guaranteed that x is smaller than y.
You would like to travel through all the cities using the shortest path possible. Given n, x, y and a description of the spanning tree that was chosen, find the cost of the shortest path that starts in any city, ends in any city and visits all cities exactly once.
-----Input-----
The first line of the input contains three integers n, x and y (2 ≤ n ≤ 200 000, 1 ≤ x, y ≤ 10^9).
Each of the next n - 1 lines contains a description of a road in the spanning tree. The i-th of these lines contains two integers u_{i} and v_{i} (1 ≤ u_{i}, v_{i} ≤ n) — indices of the cities connected by the i-th road. It is guaranteed that these roads form a spanning tree.
-----Output-----
Print a single integer — the minimum number of seconds one needs to spend in order to visit all the cities exactly once.
-----Examples-----
Input
5 2 3
1 2
1 3
3 4
5 3
Output
9
Input
5 3 2
1 2
1 3
3 4
5 3
Output
8
-----Note-----
In the first sample, roads of the spanning tree have cost 2, while other roads have cost 3. One example of an optimal path is $5 \rightarrow 3 \rightarrow 4 \rightarrow 1 \rightarrow 2$.
In the second sample, we have the same spanning tree, but roads in the spanning tree cost 3, while other roads cost 2. One example of an optimal path is $1 \rightarrow 4 \rightarrow 5 \rightarrow 2 \rightarrow 3$.
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 defaultdict
from collections import deque
from functools import reduce
n, x, y = [int(x) for x in input().split()]
E = defaultdict(set)
for i in range(n-1):
u, v = [int(x) for x in input().split()]
E[u].add(v)
E[v].add(u)
if x > y:
for v in E:
if len(E[v]) == n-1:
print((n-2)*y + x)
break
elif len(E[v]) > 1:
print((n-1)*y)
break
else:
visited = {v : False for v in E}
stack = [1]
topsorted = deque()
while stack:
v = stack.pop()
if visited[v]: continue
visited[v] = True
topsorted.appendleft(v)
stack.extend(E[v])
chopped = set()
ans = 0
for v in topsorted:
ans += max(0, len(E[v])-2)
if len(E[v]) > 2:
S = E[v].intersection(chopped)
S1 = {S.pop(), S.pop()}
for u in E[v]:
if not u in S1:
E[u].remove(v)
E[v].clear()
E[v].update(S1)
chopped.add(v)
print(ans*y + (n-1-ans)*x)
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Do you know that The Chef has a special interest in palindromes? Yes he does! Almost all of the dishes in his restaurant is named by a palindrome strings. The problem is that a name of a dish should not be too long, so The Chef has only limited choices when naming a new dish.
For the given positive integer N, your task is to calculate the number of palindrome strings of length not exceeding N, that contain only lowercase letters of English alphabet (letters from 'a' to 'z', inclusive). Recall that a palindrome is a string that reads the same left to right as right to left (as in "radar").
For example:
- For N = 1, we have 26 different palindromes of length not exceeding N:
"a", "b", ..., "z".
- For N = 2 we have 52 different palindromes of length not exceeding N:
"a", "b", ..., "z",
"aa", "bb", ..., "zz".
- For N = 3 we have 728 different palindromes of length not exceeding N:
"a", "b", ..., "z",
"aa", "bb", ..., "zz",
"aaa", "aba", ..., "aza",
"bab", "bbb", ..., "bzb",
...,
"zaz", "zbz", ..., "zzz".
Since the answer can be quite large you should output it modulo 1000000007 (109 + 7). Yes, we know, most of you already hate this modulo, but there is nothing we can do with 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 only line of each test case contains a single integer N.
-----Output-----
For each test case, output a single line containing the answer for the corresponding test case.
-----Constrains-----
- 1 ≤ T ≤ 1000
- 1 ≤ N ≤ 109
-----Example-----
Input:
5
1
2
3
4
100
Output:
26
52
728
1404
508533804
-----Explanation-----
The first three examples are explained in the problem statement above.
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 permutation(n,p):
r=26
if n==1:
return 26
elif n==2:
return 52
elif n==3:
return 728
else:
if n%2==0:
return ((2*(bin_expo(r,((n//2)+1),p)-r)*bin_expo(25,1000000005,p)))%p
else:
n=n+1
return ((2*((bin_expo(r,(n//2+1),p)-r)*bin_expo(r-1,1000000005,p)))- bin_expo(26,n//2,p))%p
def bin_expo(x,n,p):
if n==0:
return 1
elif n==1:
return x%p
else:
temp=bin_expo(x,n//2,p)
temp=(temp*temp)%p
if n%2==0:
return temp
else:
return ((x%p)*temp)%p
test=int(input())
for _ in range(test):
n=int(input())
p=1000000007
print(int(permutation(n,p)))
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Is it rated?
Here it is. The Ultimate Question of Competitive Programming, Codeforces, and Everything. And you are here to answer it.
Another Codeforces round has been conducted. No two participants have the same number of points. For each participant, from the top to the bottom of the standings, their rating before and after the round is known.
It's known that if at least one participant's rating has changed, then the round was rated for sure.
It's also known that if the round was rated and a participant with lower rating took a better place in the standings than a participant with higher rating, then at least one round participant's rating has changed.
In this problem, you should not make any other assumptions about the rating system.
Determine if the current round is rated, unrated, or it's impossible to determine whether it is rated of not.
-----Input-----
The first line contains a single integer n (2 ≤ n ≤ 1000) — the number of round participants.
Each of the next n lines contains two integers a_{i} and b_{i} (1 ≤ a_{i}, b_{i} ≤ 4126) — the rating of the i-th participant before and after the round, respectively. The participants are listed in order from the top to the bottom of the standings.
-----Output-----
If the round is rated for sure, print "rated". If the round is unrated for sure, print "unrated". If it's impossible to determine whether the round is rated or not, print "maybe".
-----Examples-----
Input
6
3060 3060
2194 2194
2876 2903
2624 2624
3007 2991
2884 2884
Output
rated
Input
4
1500 1500
1300 1300
1200 1200
1400 1400
Output
unrated
Input
5
3123 3123
2777 2777
2246 2246
2246 2246
1699 1699
Output
maybe
-----Note-----
In the first example, the ratings of the participants in the third and fifth places have changed, therefore, the round was rated.
In the second example, no one's rating has changed, but the participant in the second place has lower rating than the participant in the fourth place. Therefore, if the round was rated, someone's rating would've changed for sure.
In the third example, no one's rating has changed, and the participants took places in non-increasing order of their rating. Therefore, it's impossible to determine whether the round is rated or not.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
'''input
5
3123 3123
2777 2777
2246 2246
2246 2246
1699 1699
'''
n = int(input())
x = []
f = 0
for _ in range(n):
a, b = list(map(int, input().split()))
if a != b:
f = 1
x.append(a)
if f == 1:
print("rated")
elif sorted(x)[::-1] == x:
print("maybe")
else:
print("unrated")
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
You are given a system of pipes. It consists of two rows, each row consists of $n$ pipes. The top left pipe has the coordinates $(1, 1)$ and the bottom right — $(2, n)$.
There are six types of pipes: two types of straight pipes and four types of curved pipes. Here are the examples of all six types:
[Image] Types of pipes
You can turn each of the given pipes $90$ degrees clockwise or counterclockwise arbitrary (possibly, zero) number of times (so the types $1$ and $2$ can become each other and types $3, 4, 5, 6$ can become each other).
You want to turn some pipes in a way that the water flow can start at $(1, 0)$ (to the left of the top left pipe), move to the pipe at $(1, 1)$, flow somehow by connected pipes to the pipe at $(2, n)$ and flow right to $(2, n + 1)$.
Pipes are connected if they are adjacent in the system and their ends are connected. Here are examples of connected pipes:
[Image] Examples of connected pipes
Let's describe the problem using some example:
[Image] The first example input
And its solution is below: [Image] The first example answer
As you can see, the water flow is the poorly drawn blue line. To obtain the answer, we need to turn the pipe at $(1, 2)$ $90$ degrees clockwise, the pipe at $(2, 3)$ $90$ degrees, the pipe at $(1, 6)$ $90$ degrees, the pipe at $(1, 7)$ $180$ degrees and the pipe at $(2, 7)$ $180$ degrees. Then the flow of water can reach $(2, n + 1)$ from $(1, 0)$.
You have to answer $q$ independent queries.
-----Input-----
The first line of the input contains one integer $q$ ($1 \le q \le 10^4$) — the number of queries. Then $q$ queries follow.
Each query consists of exactly three lines. The first line of the query contains one integer $n$ ($1 \le n \le 2 \cdot 10^5$) — the number of pipes in each row. The next two lines contain a description of the first and the second rows correspondingly. Each row description consists of $n$ digits from $1$ to $6$ without any whitespaces between them, each digit corresponds to the type of pipe in the corresponding cell. See the problem statement to understand which digits correspond to which types of pipes.
It is guaranteed that the sum of $n$ over all queries does not exceed $2 \cdot 10^5$.
-----Output-----
For the $i$-th query print the answer for it — "YES" (without quotes) if it is possible to turn some pipes in a way that the water flow can reach $(2, n + 1)$ from $(1, 0)$, and "NO" otherwise.
-----Example-----
Input
6
7
2323216
1615124
1
3
4
2
13
24
2
12
34
3
536
345
2
46
54
Output
YES
YES
YES
NO
YES
NO
-----Note-----
The first query from the example is described 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
ans = []
for _ in range(int(input())):
n = int(input())
s = list(input())
t = list(input())
lvl = 0
X = [s, t]
f = 1
for i in range(n):
if s[i] in '3456' and t[i] in '3456':
lvl = 1 - lvl
elif X[lvl][i] in '3456':
f = 0
ans.append('NO')
break
if f and lvl == 1:
ans.append('YES')
elif f:
ans.append('NO')
print('\n'.join(ans))
``` |
|
open-r1/verifiable-coding-problems-python-10k | Solve the following coding problem using the programming language python:
Kira likes to play with strings very much. Moreover he likes the shape of 'W' very much. He takes a string and try to make a 'W' shape out of it such that each angular point is a '#' character and each sides has same characters. He calls them W strings.
For example, the W string can be formed from "aaaaa#bb#cc#dddd" such as:
a
a d
a # d
a b c d
a b c d
# #
He also call the strings which can generate a 'W' shape (satisfying the above conditions) W strings.
More formally, a string S is a W string if and only if it satisfies the following conditions (some terms and notations are explained in Note, please see it if you cannot understand):
- The string S contains exactly 3 '#' characters. Let the indexes of all '#' be P1 < P2 < P3 (indexes are 0-origin).
- Each substring of S[0, P1−1], S[P1+1, P2−1], S[P2+1, P3−1], S[P3+1, |S|−1] contains exactly one kind of characters, where S[a, b] denotes the non-empty substring from a+1th character to b+1th character, and |S| denotes the length of string S (See Note for details).
Now, his friend Ryuk gives him a string S and asks him to find the length of the longest W string which is a subsequence of S, with only one condition that there must not be any '#' symbols between the positions of the first and the second '#' symbol he chooses, nor between the second and the third (here the "positions" we are looking at are in S), i.e. suppose the index of the '#'s he chooses to make the W string are P1, P2, P3 (in increasing order) in the original string S, then there must be no index i such that S[i] = '#' where P1 < i < P2 or P2 < i < P3.
Help Kira and he won't write your name in the Death Note.
Note:
For a given string S, let S[k] denote the k+1th character of string S, and let the index of the character S[k] be k. Let |S| denote the length of the string S. And a substring of a string S is a string S[a, b] = S[a] S[a+1] ... S[b], where 0 ≤ a ≤ b < |S|. And a subsequence of a string S is a string S[i0] S[i1] ... S[in−1], where 0 ≤ i0 < i1 < ... < in−1 < |S|.
For example, let S be the string "kira", then S[0] = 'k', S[1] = 'i', S[3] = 'a', and |S| = 4. All of S[0, 2] = "kir", S[1, 1] = "i", and S[0, 3] = "kira" are substrings of S, but "ik", "kr", and "arik" are not. All of "k", "kr", "kira", "kia" are subsequences of S, but "ik", "kk" are not.
From the above definition of W string, for example, "a#b#c#d", "aaa#yyy#aaa#yy", and "o#oo#ooo#oooo" are W string, but "a#b#c#d#e", "#a#a#a", and "aa##a#a" are not.
-----Input-----
First line of input contains an integer T, denoting the number of test cases. Then T lines follow. Each line contains a string S.
-----Output-----
Output an integer, denoting the length of the longest W string as explained before. If S has no W string as its subsequence, then output 0.
-----Constraints-----
- 1 ≤ T ≤ 100
- 1 ≤ |S| ≤ 10000 (104)
- S contains no characters other than lower English characters ('a' to 'z') and '#' (without quotes)
-----Example-----
Input:
3
aaaaa#bb#cc#dddd
acb#aab#bab#accba
abc#dda#bb#bb#aca
Output:
16
10
11
-----Explanation-----
In the first case: the whole string forms a W String.
In the second case: acb#aab#bab#accba, the longest W string is acb#aab#bab#accba
In the third case: abc#dda#bb#bb#aca, note that even though abc#dda#bb#bb#aca (boldened characters form the subsequence) is a W string of length 12, it violates Ryuk's condition that there should not be any #'s inbetween the 3 chosen # positions. One correct string of length 11 is abc#dda#bb#bb#aca
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
def frequency(s,n):
f=[[0 for i in range(26)]for j in range(n+1)]
count=0
for i in range(n):
if s[i]!="#":
f[count][ord(s[i])-97]+=1
else:
count+=1
for j in range(26):
f[count][j]=f[count-1][j]
return (f,count)
def solve(s):
n=len(s)
f,count=frequency(s,n)
if count<3:
return 0
ans=0
index=[]
for i in range(n-1,-1,-1):
if s[i]=="#":
index.append(i)
for c in range(1,count-2+1):
if index[-2]==index[-1]+1 or index[-3]==index[-2]+1:
index.pop()
continue
left=max(f[c-1])
mid1=0
mid2=0
right=0
for j in range(26):
mid1=max(mid1,f[c][j]-f[c-1][j])
mid2=max(mid2,f[c+1][j]-f[c][j])
right=max(right,f[count][j]-f[c+1][j])
if left and mid1 and mid2 and right:
ans=max(ans,left+mid1+mid2+right)
index.pop()
return ans
for _ in range(int(input())):
s=input()
ans=solve(s)
if ans:
print(ans+3)
else:
print(0)
``` |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.