source
stringclasses 1
value | task_type
stringclasses 1
value | in_source_id
stringlengths 1
4
| problem
stringlengths 488
6.07k
| gold_standard_solution
stringlengths 19
30.1k
| verification_info
dict | metadata
dict | problem_id
stringlengths 5
9
|
|---|---|---|---|---|---|---|---|
apps | verifiable_code | 1376 | Solve the following coding problem using the programming language python:
Salmon loves to be a tidy person. One day, when he looked at the mess that he made after playing with his rubber ducks, he felt awful. Now he wants to clean up his mess, by placing his ducks into boxes.
Each rubber duck has a color. There are a total of $N+1$ colors, numbered from $0$ to $N$. Salmon wants to place his $N*K$ ducks into $N$ boxes, each of which can fit $K$ ducks. Each duck should be placed inside a box.
Salmon is very particular when it comes to how many colors he can place in each box. Since Salmon doesn't like lots of colors mixing together he only wants to have a maximum of $2$ distinct colors per box.
Please help Salmon achieve this goal!
It can be shown that there will always be at least one valid solution under given constraints.
If there are multiple correct solutions, you may output any one of them.
-----Input:-----
- The first line contains an integer $T$, denoting the number of testcases. $T$ testcases will follow, each containing two lines.
- The first line of each testcase contains two space-separated integers $N$ and $K$.
- The second line of each testcase contains $N+1$ space-separated integers. The $i+1$-th integer denotes the number of ducks with color-$i$ where $0 \leq i \leq N$
-----Output:-----
- Output $N$ lines for each testcase.
- The $i$-th line of a testcase should contain $4$ space-separated integers $c1, m1, c2, m2$ respectively which denotes that that are $m1$ ducks of color-$c1$ and $m2$ ducks of color-$c2$ inside the $i$-th box where $0 \leq m1,m2 \leq K$ and $0 \leq c1,c2 \leq N$.
- Note that even if you have only one color to put inside the $i$-th box, you should still output $4$ space-separated integers and keep either $m1$ or $m2$ as $0$. And $0 \leq c1,c2 \leq N$.
- The output should be valid and should satisfy Salmon's goal.
-----Constraints-----
- $T=10$
- $2 \leq N \leq 10^5$
- $2 \leq K \leq 10^5$
- Total ducks for each test case is exactly $N*K$
- There can be a color with $0$ ducks
-----Subtasks-----
- Subtask 1 [20 points]: $2 \leq N \leq 10$, $K=2$
- Subtask 2 [30 points]: $N=2$, $K=5$
- Subtask 3 [50 points]: original constraints
-----Sample Input:-----
1
2 4
3 4 1
-----Sample Output:-----
2 1 1 3
1 1 0 3
-----Explanation:-----
- In the given testcase, Salmon has $N=2$ boxes, each of size $K=4$ and there are total $N*K=8$ ducks.
- The first box is filled with $1$ duck of color-$2$ and $3$ ducks of color-$1$ and the second box is filled with $1$ duck of color-$1$ and $3$ ducks of color-$0$.
- Each duck is inside a box and each box has at most two distinct colors. Also each box contains exactly $K=4$ ducks.
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())):
n,k=map(int,input().split())
c=[int(i) for i in input().split()]
i=0
m=0
if(n==2 and k==5):
c1=c
c.sort()
d=dict()
for i in range(len(c)):
for j in range(len(c1)):
if(c[i]==c1[j]):
d[i]=j
c1[j]=-1
break
while(m<n):
if (i==n):
print(d[n],k,d[n-1],0)
c[n]-=k
m+=1
else:
if(c[i]>=k):
print(d[i],k,d[i+1],0)
c[i]=c[i]-k
m+=1
elif(c[i]==0):
i+=1
else:
for j in range(i+1,n+1):
if(c[i]+c[j]>=k):
print(d[i],c[i],d[j],k-c[i])
c[j]-=k-c[i]
c[i]=0
m+=1
break
else:
while(m<n):
if (i==n):
print(n,k,n-1,0)
c[n]-=k
m+=1
else:
if(c[i]>=k):
print(i,k,i+1,0)
c[i]=c[i]-k
m+=1
elif(c[i]==0):
i+=1
else:
for j in range(i+1,n+1):
if(c[i]+c[j]>=k):
print(i,c[i],j,k-c[i])
c[j]-=k-c[i]
c[i]=0
m+=1
break
``` | {
"language": "python",
"test_cases": [
{
"input": "1\n2 4\n3 4 1\n",
"output": "2 1 1 3\n1 1 0 3\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/UWCOI21/problems/UWCOI21C"
} | vfc_4346 |
apps | verifiable_code | 1377 | Solve the following coding problem using the programming language python:
-----General Statement:-----
Given the actual high and low temperatures for the day and the normal high and low temperatures for that day, calculate the average difference from normal.
-----Input:-----
The first line of the data set for this problem is an integer that represents the number of data sets that follow. Each data set is on a separate line and consists of today’s high, today’s low, normal high, and normal low – in that order.
-----Output:-----
If the average difference is negative, do not output the negative sign (-).
Output the amount of deviation from normal, followed by the words
DEGREE(S) ABOVE NORMAL, or by the words
DEGREE(S) BELOW NORMAL.
Round to 1 decimal place. A trailing zero is required if the average is an integer.
The output is to be formatted exactly like that for the sample output given below.
-----Assumptions:-----
Temperatures are in the range –15..100 degrees.
The average temperature difference will not be zero.
-----Discussion:-----
Determine the average of the difference of the high temperatures and the difference of the low temperatures.
-----Sample Input:-----
3
75 45 78 40
50 32 45 30
56 48 62 45
-----Sample Output:-----
1.0 DEGREE(S) ABOVE NORMAL
3.5 DEGREE(S) ABOVE NORMAL
1.5 DEGREE(S) BELOW NORMAL
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())):
x1,y1,x2,y2=map(int,input().split())
av1=(x1+y1)/2
av2=(x2+y2)/2
if(av1>av2):
print(av1-av2," DEGREE(S) ABOVE NORMAL")
else:
print(av2-av1," DEGREE(S) BELOW NORMAL")
``` | {
"language": "python",
"test_cases": [
{
"input": "3\n75 45 78 40\n50 32 45 30\n56 48 62 45\n",
"output": "1.0 DEGREE(S) ABOVE NORMAL\n3.5 DEGREE(S) ABOVE NORMAL\n1.5 DEGREE(S) BELOW NORMAL\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/QTCC2020/problems/VIEW2005"
} | vfc_4350 |
apps | verifiable_code | 1378 | Solve the following coding problem using the programming language python:
There are K nuclear reactor chambers labelled from 0 to K-1. Particles are bombarded onto chamber 0. The particles keep collecting in the chamber 0. However if at any time, there are more than N particles in a chamber, a reaction will cause 1 particle to move to the immediate next chamber(if current chamber is 0, then to chamber number 1), and all the particles in the current chamber will be be destroyed and same continues till no chamber has number of particles greater than N. Given K,N and the total number of particles bombarded (A), find the final distribution of particles in the K chambers. Particles are bombarded one at a time. After one particle is bombarded, the set of reactions, as described, take place. After all reactions are over, the next particle is bombarded. If a particle is going out from the last chamber, it has nowhere to go and is lost.
-----Input-----
The input will consist of one line containing three numbers A,N and K separated by spaces.
A will be between 0 and 1000000000 inclusive.
N will be between 0 and 100 inclusive.
K will be between 1 and 100 inclusive.
All chambers start off with zero particles initially.
-----Output-----
Consists of K numbers on one line followed by a newline. The first number is the number of particles in chamber 0, the second number is the number of particles in chamber 1 and so on.
-----Example-----
Input:
3 1 3
Output:
1 1 0
Explanation
Total of 3 particles are bombarded. After particle 1 is bombarded, the chambers have particle distribution as
"1 0 0". After second particle is bombarded, number of particles in chamber 0 becomes 2 which is greater
than 1. So, num of particles in chamber 0 becomes 0 and in chamber 1 becomes 1. So now distribution is
"0 1 0". After the 3rd particle is bombarded, chamber 0 gets 1 particle and so distribution is "1 1 0" after all
particles are bombarded 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
a,n,k = map(int,input().split())
for i in range(k):
print(a%(n+1),end=' ')
a=a//(n+1)
``` | {
"language": "python",
"test_cases": [
{
"input": "3 1 3\n",
"output": "1 1 0\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/NUKES"
} | vfc_4354 |
apps | verifiable_code | 1379 | Solve the following coding problem using the programming language python:
A simple string contains a large repetition of letters within it. This problem is related to string handling and manipulation. An original message is sent from planet Earth to planet Cybertron in form of a string. However, the letter position and string size is not important. The number of time each letter has occurred in the string is important. So the original string which is sent to Cybertron is encrypted in the new string which comprises the letters followed by each time it has occurred in the original string. Eg- original message is- abcdabf. Then the encrypted string is- a2b2c1d1f1
-----Input-----
The input consists of a single line string without any space or numeric or special characters.
-----Output-----
It will consist of in the encrypted string which comprises the letters followed by each time it has occurred in the original string in order.
-----Example-----
Input:
information
Output:
i2n2f1o2r1m1a1t1
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
import sys,math
def main(filename):
inputfile = open(filename,'rU')
data = inputfile.readlines()
T=data.pop(0)
ans=[]
ansstring=str()
explored=[]
for i in T:
if i in explored:
#print explored
for j in range(len(ans)):
if ans[j][0]==i:
ans[j][1] += 1
else:
ans.append([i,1])
explored.append(i)
for i in ans:
ansstring += i[0]+str(i[1])
print(ansstring)
inputfile.close()
def __starting_point():
main(sys.argv[1])
__starting_point()
``` | {
"language": "python",
"test_cases": [
{
"input": "information\n",
"output": "i2n2f1o2r1m1a1t1\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/TCTR2012/problems/NOPC9"
} | vfc_4358 |
apps | verifiable_code | 1380 | Solve the following coding problem using the programming language python:
The chef was searching for his pen in the garage but he found his old machine with a display and some numbers on it. If some numbers entered then some different output occurs on the display. Chef wants to crack the algorithm that the machine is following.
Example to identify the pattern :
Input Output
9 36
5 10
1 0
2 1
-----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 as displayed on the screen.
-----Constraints-----
- $1 \leq T \leq 10^6$
- $1 \leq N \leq 10^6$
-----Sample Input:-----
1
7
-----Sample Output:-----
21
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 t in range(T):
N = int(input())
print(int(((N-1)*(N))/2))
``` | {
"language": "python",
"test_cases": [
{
"input": "1\n7\n",
"output": "21\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/PBK32020/problems/ITGUY29"
} | vfc_4362 |
apps | verifiable_code | 1381 | Solve the following coding problem using the programming language python:
Chef works as a cook in a restaurant. Each morning, he has to drive down a straight road with length K$K$ to reach the restaurant from his home. Let's describe this road using a coordinate X$X$; the position of Chef's home is X=0$X = 0$ and the position of the restaurant is X=K$X = K$.
The road has exactly two lanes (numbered 1$1$ and 2$2$), but there are N$N$ obstacles (numbered 1$1$ through N$N$) on it. For each valid i$i$, the i$i$-th obstacle blocks the lane Li$L_i$ at the position X=Xi$X = X_i$ and does not block the other lane.
When driving, Chef cannot pass through an obstacle. He can switch lanes in zero time at any integer X$X$-coordinate which does not coincide with the X$X$-coordinate of any obstacle. However, whenever he switches lanes, he cannot switch again until driving for at least D$D$ units of distance, and he can travel only in the direction of increasing X$X$. Chef can start driving in any lane he wants. He can not switch lanes at non-integer X$X$-coordinate.
Sometimes, it is impossible to reach the restaurant without stopping at an obstacle. Find the maximum possible distance Chef can travel before he has to reach an obstacle which is in the same lane as him. If he can avoid all obstacles and reach the restaurant, the answer is K$K$.
-----Input-----
- The first line of the input contains a single integer T$T$ denoting the number of test cases. The description of T$T$ test cases follows.
- The first line of each test case contains three space-separated integers N$N$, K$K$ and D$D$.
- The second line contains N$N$ space-separated integers X1,X2,…,XN$X_1, X_2, \ldots, X_N$.
- The third line contains N$N$ space-separated integers L1,L2,…,LN$L_1, L_2, \ldots, L_N$.
-----Output-----
For each test case, print a single line containing one integer ― the maximum distance Chef can travel.
-----Constraints-----
- 1≤T≤1,000$1 \le T \le 1,000$
- 1≤N≤105$1 \le N \le 10^5$
- 2≤K≤109$2 \le K \le 10^9$
- 1≤D≤109$1 \le D \le 10^9$
- 1≤Xi≤K−1$1 \le X_i \le K-1$ for each valid i$i$
- Xi<Xi+1$X_i < X_{i+1}$ for each valid i$i$
- 1≤Li≤2$1 \le L_i \le 2$ for each valid i$i$
- the sum of N$N$ over all test cases does not exceed 106$10^6$
-----Subtasks-----
Subtask #1 (100 points): original constraints
-----Example Input-----
4
2 10 20
4 7
1 2
4 15 20
4 6 9 13
1 2 2 1
5 10 1
1 3 5 7 9
1 2 1 2 1
2 10 2
4 5
1 2
-----Example Output-----
10
13
10
5
-----Explanation-----
Example case 1: Chef can start in lane 2$2$ and switch to lane 1$1$ at the position X=6$X = 6$, then continue until reaching the restaurant.
Example case 2: Chef can start in lane 2$2$ and switch to lane 1$1$ at X=5$X = 5$. However, he cannot avoid the obstacle at X=13$X = 13$, because he has not driven for at least 20$20$ units since the last switch.
Example case 3: Chef should start in lane 2$2$ and then switch lanes at the positions X=2$X=2$, X=4$X=4$, X=6$X=6$ and X=8$X=8$. This way, he can reach the restaurant.
Example case 4: Chef can start in lane 2$2$ but he cannot escape the second obstacle at X$X$=5 since the first obstacle at X$X$=4 doesn't give enough space for Chef to switch lanes.
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, k, d = list(map(int, input().split()))
x = list(map(int, input().split()))
l = list(map(int, input().split()))
lane = 3 - l[0]
switched = -float('inf')
ans = k
for i in range(n):
if l[i] == lane:
if switched + d < x[i] and x[i - 1] + 1 < x[i]:
lane = 3 - lane
switched = max(x[i - 1] + 1, switched + d)
else:
ans = x[i]
break
print(ans)
``` | {
"language": "python",
"test_cases": [
{
"input": "4\n2 10 20\n4 7\n1 2\n4 15 20\n4 6 9 13\n1 2 2 1\n5 10 1\n1 3 5 7 9\n1 2 1 2 1\n2 10 2\n4 5\n1 2\n",
"output": "10\n13\n10\n5\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/TWOLANE"
} | vfc_4366 |
apps | verifiable_code | 1382 | Solve the following coding problem using the programming language python:
Chef has an array of N integers. He wants to play a special game. In this game he needs to make all the integers in the array greater than or equal to 0.
Chef can use two types of operations. The first type is to increase all the integers of the given array by 1, but it costs X coins. The operation of the second type is to add 1 to only one integer of the given array and to use this operation you need to pay 1 coin. You need to calculate the minimal cost to win this game (to make all integers greater than or equal to 0)
-----Input-----
The first line of the input contains an integer N denoting the number of elements in the given array. The second line contains N space-separated integers A1, A2, ..., AN denoting the given array. The third line contains number X - cost of the first type operation.
-----Output-----
For each test case, output a single line containing minimal cost required to make all the integers greater than or equal to zero.
-----Constraints-----
- 1 ≤ N ≤ 105
- -109 ≤ Ai ≤ 109
- 0 ≤ X ≤ 109
-----Example-----
Input:
3
-1 -2 -3
2
Output:
5
-----Explanation-----
Example case 1: Use the first type operation twice and the second type once.
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()))
x=int(input())
l=[]
for i in a:
if i<0:
l.append(-i)
l.sort()
m=len(l)
ans=0
if l:
if x>n:
ans=sum(l)
else:
ans=sum(l[m-x:])
print(ans)
``` | {
"language": "python",
"test_cases": [
{
"input": "3\n-1 -2 -3\n2\n",
"output": "5\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/INTEG"
} | vfc_4370 |
apps | verifiable_code | 1383 | 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)
``` | {
"language": "python",
"test_cases": [
{
"input": "1\n4 1 4\n2 2 2 2\n",
"output": "8\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/QFUN2020/problems/CHEMFACT"
} | vfc_4374 |
apps | verifiable_code | 1384 | Solve the following coding problem using the programming language python:
On each of the following $N$ days (numbered $1$ through $N$), Chef is planning to cook either pizza or broccoli. He wrote down a string $A$ with length $N$, where for each valid $i$, if the character $A_i$ is '1', then he will cook pizza on the $i$-th day, while if $A_i$ is '0', he will cook broccoli on this day.
Chefu, his son, loves pizza but hates broccoli ― just like most kids. He wants to select a substring of $A$ with length $K$ and change each character '0' in this substring to '1'. Afterwards, let's define pizza time as the maximum number of consecutive days where Chef will cook pizza. Find the maximum pizza time Chefu can achieve.
-----Input-----
- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
- The first line of each test case contains two space-separated integers $N$ and $K$.
- The second line contains a string $A$ with length $N$.
-----Output-----
For each test case, print a single line containing one integer ― the maximum pizza time.
-----Constraints-----
- $1 \le T \le 1,000$
- $1 \le K \le N \le 10^5$
- $A$ contains only characters '0' and '1'
- the sum of $N$ over all test cases does not exceed $10^6$
-----Subtasks-----
Subtask #1 (50 points):
- $N \le 10^3$
- the sum of $N$ over all test cases does not exceed $10^4$
Subtask #2 (50 points): original constraints
-----Example Input-----
2
13 2
0101110000101
6 3
100001
-----Example Output-----
5
4
-----Explanation-----
Example case 1: Chefu can choose the substring $A[2, 3]$ = "10", and change the third character of $A$ to '1'. Then, the pizza time is $5$ days: from day $2$ to day $6$.
Example case 2: Chefu can choose the substring $A[2, 4]$ = "000". Then, the pizza time is $4$ days: from day $1$ to day $4$.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
for _ in range(int(input())):
n, k = map(int, input().split())
l = [*map(int, input())]
count = [0] * (n + 1)
for i in range(n - 1, -1, -1):
if l[i] == 1:
count[i] = count[i + 1] + 1
x,y = 0,0
for i in range(n):
if l[i] == 1:
x += 1
else:
try:
y = max(y, x + k + count[i + k])
except:
y = max(y, x + min(k, n - i))
x = 0
y = max(y,x)
print(y)
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n13 2\n0101110000101\n6 3\n100001\n",
"output": "5\n4\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/PIBRO"
} | vfc_4378 |
apps | verifiable_code | 1385 | Solve the following coding problem using the programming language python:
Gru has a string $S$ of length $N$, consisting of only characters $a$ and $b$ for banana and $P$ points to spend.
Now Gru wants to replace and/or re-arrange characters of this given string to get the lexicographically smallest string possible. For this, he can perform the following two operations any number of times.
1) Swap any two characters in the string. This operation costs $1$ $point$. (any two, need not be adjacent)
2) Replace a character in the string with any other lower case english letter. This operation costs $2$ $points$.
Help Gru in obtaining the lexicographically smallest string possible, by using at most $P$ points.
-----Input:-----
- First line will contain $T$, number of testcases. Then the testcases follow.
- Each testcase contains two lines of input, first-line containing two integers $N$ , $P$.
- The second line contains a string $S$ consisting of $N$ characters.
-----Output:-----
For each testcase, output in a single containing the lexicographically smallest string obtained.
-----Constraints-----
- $1 \leq T \leq 10$
- $1 \leq N \leq 10^5$
- $0 \leq P \leq 2N$
- $S$ only consists of $'a'$ and $'b'$
-----Sample Input:-----
1
3 3
bba
-----Sample Output:-----
aab
-----Explanation:-----
We swap $S[0]$ and $S[2]$, to get $abb$. With the 2 remaining points, we replace $S[1]$ to obtain $aab$ which is the lexicographically smallest string possible for this case.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
def __starting_point():
t=int(input())
for _ in range(t):
n,p=input().split()
n,p=int(n),int(p)
s=input()
a,b=0,0
arr=[0]*n
for i in range(n):
arr[i]=s[i]
for c in s:
if c=='a':
a+=1
else:
b+=1
swap=0
for i in range(a):
if s[i]=='b':
swap+=1
tmpp=p
if p<=swap:
for i in range(n):
if p==0:
break
if arr[i]=='b':
arr[i]='a'
p-=1
p=tmpp
for i in range(n-1,-1,-1):
if p==0:
break
if arr[i]=='a':
arr[i]='b'
p-=1
for c in arr:
print(c,end="")
print()
else:
for i in range(n):
if i<a:
arr[i]='a'
else:
arr[i]='b'
p-=swap
for i in range(n):
if arr[i]=='b':
if s[i]=='b' and p>=2:
p-=2
arr[i]='a'
if s[i]=='a' and p>=1:
p-=1
arr[i]='a'
for c in arr:
print(c,end="")
print()
__starting_point()
``` | {
"language": "python",
"test_cases": [
{
"input": "1\n3 3\nbba\n",
"output": "aab\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/BANSTR"
} | vfc_4382 |
apps | verifiable_code | 1386 | Solve the following coding problem using the programming language python:
-----Problem description-----
As a holiday gift, Tojo received a probability problem. The problem read as follows
Consider an N by M grid. Rows are numbered 1 to N, from top to bottom. Columns are numbered 1 to M, from left to right. You are initially at cell (1, 1) and want to go to cell (N, M). From any cell you can move to the cell below it or to the cell right to it. You should never go out of the grid. At any point you should consider all the possibilities of movement with equal probability
Let P[i][j] be the probability of visiting cell (i, j). You need to calculate the sum of P[i][j] for 1 ≤ i ≤ N, 1 ≤ i ≤ M.
As we all know, Tojo really hates probability related problems. He wants you to solve this task
-----Input-----
The first line of the input contains an integer T denoting the number of test cases. The description of T test cases follows.Only line of each test case has two integer N and M.
-----Output-----
For each test case, output a single line containing the required answer. Answers within an absolute or relative error of 10-6 will be accepted.
-----Constraints-----
- 1 ≤ T ≤ 1000
- 1 ≤ N ≤ 1000
- 1 ≤ M ≤ 1000
-----Example-----
Input:
2
2 2
1 6
Output:
3.000000
6.000000
-----Explanation-----
Example case 1
Probability matrix P for N=2, M=2 is
1.0 0.5
0.5 1.0
You are at (1, 1) initially. So the probablity of visiting (1, 1) is 1. At (1, 1) you have 2 options, move below to (2, 1) or to right cell (1, 2). Probablity of going to (1, 2) is 0.5. Probability of going to (2, 1) is 0.5. You always end up at (2, 2), so P[2][2] is 1. Required sum = 1.0 + 0.5 + 0.5 + 1.0 = 3.0
Example case 2
Probability matrix P for N=1, M=6 is
1.0 1.0 1.0 1.0 1.0 1.0
Because at any position there is only one possible next position.
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 factorial
for _ in range(int(input())):
N,M=[int(a) for a in input().split()]
print(float(N+M-1))
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n2 2\n1 6\n",
"output": "3.000000\n6.000000\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/ANUTHM"
} | vfc_4386 |
apps | verifiable_code | 1388 | 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)
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n600000\n250000\n",
"output": "577500\n250000\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/SLAB"
} | vfc_4394 |
apps | verifiable_code | 1389 | Solve the following coding problem using the programming language python:
In this problem the input will consist of a number of lines of English text consisting of the letters of the English alphabet, the punctuation marks ' (apostrophe), . (full stop), , (comma), ; (semicolon), :(colon) and white space characters (blank, newline). Your task is print the words in the text in reverse order without any punctuation marks.
For example consider the following candidate for the input text:
$ $
This is a sample piece of text to illustrate this
problem. If you are smart you will solve this right.
$ $
The corresponding output would read as:
$ $
right this solve will you smart are you If problem
this illustrate to text of piece sample a is This
$ $
That is, the lines are printed in reverse order and in each line the words are printed in reverse order.
-----Input:-----
The first line of input contains a single integer $N$, indicating the number of lines in the input. This is followed by $N$ lines of input text.
-----Output:-----
$N$ lines of output text containing the input lines in reverse order and where each line contains the words in reverse order as illustrated above.
-----Constraints:-----
- $1 \leq N \leq 10000$.
- There are at most $80$ characters in each line
-----Sample input-----
2
This is a sample piece of text to illustrate this
problem. If you are smart you will solve this right.
-----Sample output-----
right this solve will you smart are you If problem
this illustrate to text of piece sample a is This
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
N = int(input())
l = []
for i in range(N):
l.append(input())
for j in range(N-1,-1,-1):
s = '` '+ l[j]
n = len(s)-1
y = s[n]
f = ''
while y != '`':
w = ''
while y != ' ':
if ord(y) in range(97,123) or ord(y) in range(65,91):
w += y
n -= 1
y = s[n]
wf = ''
n -= 1
y = s[n]
x = len(w)
for k in range(x):
wf += w[x-k-1]
f += wf+' '
print(f)
``` | {
"language": "python",
"test_cases": [
{
"input": "2\nThis is a sample piece of text to illustrate this \nproblem. If you are smart you will solve this right.\n\n",
"output": "right this solve will you smart are you If problem\nthis illustrate to text of piece sample a is This\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/IARCSJUD/problems/IAREVERS"
} | vfc_4398 |
apps | verifiable_code | 1390 | Solve the following coding problem using the programming language python:
Our Chef who was a renouned mathematician has recently got into diamonds' business.
She has accidentally misplaced $Q$ diamonds into a jar which already had $N$ chocolates. She then started wondering about an interesting question as following.
If we pick items one by one at random without replacement, what would be the expected number of picks required to get all diamonds out.
-----Input:-----
- First line will contain $T$, number of testcases. Then the testcases follow.
- Each testcase contains of a single line of input, two integers $N$, $Q$.
-----Output:-----
For each testcase, output the answer in a single line. Your answer is considered if its absolute or relative error doesn't exceed $10^{-6}$
-----Constraints-----
- $1 \leq T \leq 10^5$
- $1 \leq N \leq 10^5$
- $1 \leq Q \leq 10^5$
-----Sample Input:-----
1
2 2
-----Sample Output:-----
3.3333333333
-----EXPLANATION:-----
Here there are 2 Diamonds, 2 chocolates in the jar.
Say C is chocolate, D is diamond.
If the random order of picking them from left to right is "CDDC", after 3 picks (CDD) all diamonds are out.
Similarly, for the remaining orders it would be the following:
"CDCD" => 4
"CCDD" => 4
"DDCC" => 2
"DCDC" => 3
"DCCD" => 4
Hence the expected number of picks would be (3+4+4+2+3+4)/6 = 3.333333
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 h in range(int(input())):
n,q=map(int,input().split())
print(q*(n+q+1)/(q+1))
``` | {
"language": "python",
"test_cases": [
{
"input": "1\n2 2\n",
"output": "3.3333333333\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/RANDID"
} | vfc_4402 |
apps | verifiable_code | 1391 | Solve the following coding problem using the programming language python:
Our chef has recently opened a new restaurant with a unique style. The restaurant is divided into K compartments (numbered from 1 to K) and each compartment can be occupied by at most one customer.
Each customer that visits the restaurant has a strongly preferred compartment p (1 ≤ p ≤ K), and if that compartment is already occupied, then the customer simply leaves. Now obviously, the chef wants to maximize the total number of customers that dine at his restaurant and so he allows (or disallows) certain customers so as to achieve this task. You are to help him with this.
Given a list of N customers with their arrival time, departure time and the preferred compartment, you need to calculate the maximum number of customers that can dine at the restaurant.
-----Input-----
The first line contains an integer T denoting the number of test cases. Each of the next T lines contains two integers N and K , the number of customers that plan to visit the chef's restaurant and the number of compartments the restaurant is divided into respectively. Each of the next N lines contains three integers si, fi and pi , the arrival time, departure time and the strongly preferred compartment of the ith customer respectively.
Note that the ith customer wants to occupy the pith compartment from [si, fi) i.e the ith customer leaves just before fi so that another customer can occupy that compartment from fi onwards.
-----Output-----
For every test case, print in a single line the maximum number of customers that dine at the restaurant.
-----Constraints-----
- 1 ≤ T ≤ 30
- 0 ≤ N ≤ 105
- 1 ≤ K ≤ 109
- 0 ≤ si < fi ≤ 109
- 1 ≤ pi ≤ K
-----Example-----
Input:
2
3 3
1 3 1
4 6 2
7 10 3
4 2
10 100 1
100 200 2
150 500 2
200 300 2
Output:
3
3
-----Explanation-----
Example case 1.
All three customers want different compartments and hence all 3 can be accommodated.
Example case 2.
If we serve the 1st, 2nd and 4th customers, then we can get a maximum of 3.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
try:
for _ in range(int(input())):
N, K = map(int, input().split())
cell = []
count = 0
l = []
for __ in range(N):
inserted = list(map(int, input().split()))
cell.append(inserted)
cell.sort(key=lambda x: x[1])
time = {}
for number in cell:
if number[2] not in time:
time[number[2]] = number[1]
count += 1
elif number[0] >= time[number[2]]:
time[number[2]] = number[1]
count += 1
print(count)
except:
pass
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n3 3\n1 3 1\n4 6 2\n7 10 3\n4 2\n10 100 1\n100 200 2\n150 500 2\n200 300 2\n",
"output": "3\n3\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/FGFS"
} | vfc_4406 |
apps | verifiable_code | 1392 | Solve the following coding problem using the programming language python:
Chef and Chefina are best friends. Chefina wants to test the Problem Solving skills of chef so she provides Chef 2 integer number $X$ and $Y$
The task of chef is to take the two numbers $X$ and $Y$ and return their SUM.
Identify whether Chef can solve the problem or not?
-----Input:-----
- First line will contain the two integers $X$ and $Y$.
-----Output:-----
For each testcase, output in a single line the SUM of these two numbers $X$ and $Y$.
-----Constraints-----
- $1 \leq X \leq 100$
- $1 \leq Y \leq 100$
-----Sample Input:-----
6 70
-----Sample Output:-----
76
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
a,b=map(int,input().split())
print(a+b)
``` | {
"language": "python",
"test_cases": [
{
"input": "6 70\n",
"output": "76\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/SPTC2020/problems/CPCEJC4"
} | vfc_4410 |
apps | verifiable_code | 1393 | Solve the following coding problem using the programming language python:
Most problems on CodeChef highlight chef's love for food and cooking but little is known about his love for racing sports. He is an avid Formula 1 fan. He went to watch this year's Indian Grand Prix at New Delhi. He noticed that one segment of the circuit was a long straight road. It was impossible for a car to overtake other cars on this segment. Therefore, a car had to lower down its speed if there was a slower car in front of it. While watching the race, Chef started to wonder how many cars were moving at their maximum speed.
Formally, you're given the maximum speed of N cars in the order they entered the long straight segment of the circuit. Each car prefers to move at its maximum speed. If that's not possible because of the front car being slow, it might have to lower its speed. It still moves at the fastest possible speed while avoiding any collisions. For the purpose of this problem, you can assume that the straight segment is infinitely long.
Count the number of cars which were moving at their maximum speed on the straight segment.
-----Input-----
The first line of the input contains a single integer T denoting the number of test cases to follow. Description of each test case contains 2 lines. The first of these lines contain a single integer N, the number of cars. The second line contains N space separated integers, denoting the maximum speed of the cars in the order they entered the long straight segment.
-----Output-----
For each test case, output a single line containing the number of cars which were moving at their maximum speed on the segment.
-----Example-----
Input:
3
1
10
3
8 3 6
5
4 5 1 2 3
Output:
1
2
2
-----Constraints-----
1 ≤ T ≤ 100
1 ≤ N ≤ 10,000
All speeds are distinct positive integers that fit in a 32 bit signed integer.
Each input file will not be larger than 4 MB (4,000,000,000 bytes) in size.
WARNING! The input files are very large. Use faster I/O.
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())
l = list(map(int,input().split()))
ans = 1
l1 = l[0]
for i in range(1,n):
if l[i] <= l1:
l1 = l[i]
ans = ans + 1
print(ans)
``` | {
"language": "python",
"test_cases": [
{
"input": "3\n1\n10\n3\n8 3 6\n5\n4 5 1 2 3\n",
"output": "1\n2\n2\nConstraints\n1 ≤ T ≤ 100\n1 ≤ N ≤ 10,000\nAll speeds are distinct positive integers that fit in a 32 bit signed integer.\nEach input file will not be larger than 4 MB (4,000,000,000 bytes) in size.\nWARNING! The input files are very large. Use faster I/O.\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/CARVANS"
} | vfc_4414 |
apps | verifiable_code | 1394 | Solve the following coding problem using the programming language python:
Chef's pizza is the tastiest pizza to exist, and the reason for that is his special, juicy homegrown tomatoes.
Tomatoes can be grown in rectangular patches of any side lengths. However, Chef only has a limited amount of land.
Consider the entire town of Chefville to be consisting of cells in a rectangular grid of positive coordinates.
Chef own all cells (x,y)$(x, y)$ that satisfy x∗y≤N$x*y \leq N$
As an example if N=4$N = 4$, Chef owns the following cells:
(1,1),(1,2),(1,3),(1,4),(2,1),(2,2),(3,1),(4,1)$(1, 1), (1, 2), (1, 3), (1, 4), (2, 1), (2, 2), (3, 1), (4, 1) $
Chef can only grow tomatoes in rectangular patches consisting only of cells which belong to him. Also, if he uses a cell, he must use it entirely. He cannot use only a portion of it.
Help Chef find the number of unique patches of rectangular land that he can grow tomatoes in! Since this number can be very large, output it modulo 1000000007$1000000007$.
-----Input:-----
- The first line of the input contains T$T$, the number of test cases.
- The next T$T$ lines of input contains one integer N$N$.
-----Output:-----
For each testcase, output the number of ways modulo 1000000007$1000000007$.
-----Constraints-----
- 1≤T≤5$1 \leq T \leq 5$
- 1≤N≤1010$1 \leq N \leq 10^{10}$
-----Sample Input:-----
2
4
10000000000
-----Sample Output:-----
23
227374950
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 *
def list_input():
return list(map(int,input().split()))
def map_input():
return list(map(int,input().split()))
def map_string():
return input().split()
def g(n):
return (n*(n+1)*(2*n+1))//6
def f(n):
ans = 0
for i in range(1,floor(sqrt(n))+1):
ans+=i*(i+floor(n/i))*(floor(n/i)+1-i)
return ans-g(floor(sqrt(n)))
for _ in range(int(input())):
n=int(input())
print(f(n)%1000000007)
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n4\n10000000000\n",
"output": "23\n227374950\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/PCJ18G"
} | vfc_4418 |
apps | verifiable_code | 1395 | Solve the following coding problem using the programming language python:
Ram and Shyam are sitting next to each other, hoping to cheat on an exam. However, the examination board has prepared $p$ different sets of questions (numbered $0$ through $p-1$), which will be distributed to the students in the following way:
- The students are assigned roll numbers — pairwise distinct positive integers.
- If a student's roll number is $r$, this student gets the $((r-1)\%p)$-th set of questions.
Obviously, Ram and Shyam can cheat only if they get the same set of questions.
You are given the roll numbers of Ram and Shyam: $A$ and $B$ respectively. Find the number of values of $p$ for which they can cheat, or determine that there is an infinite number of such values.
-----Input-----
- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
- The first and only line of each test case contains two space-separated integers $A$ and $B$.
-----Output-----
For each test case, print a single line — the number of values of $p$ for which Ram and Shyam can cheat, or $-1$ if there is an infinite number of such values.
-----Constraints-----
- $1 \le T \le 100$
- $1 \le A, B \le 10^8$
-----Example Input-----
1
2 6
-----Example Output-----
3
-----Explanation-----
Example case 1: They can cheat for $p = 1$, $p = 2$ or $p = 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
for test in range(0,int(input())):
A,B = map(int,input().split())
diff = abs(A-B)
count=0
if not(A^B):
print(-1)
else:
for i in range(1,int(diff**(1/2))+1):
if diff%i==0:
if diff/i==i:
count+=1
else:
count+=2
print(count)
``` | {
"language": "python",
"test_cases": [
{
"input": "1\n2 6\n",
"output": "3\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/EXAMCHT"
} | vfc_4422 |
apps | verifiable_code | 1396 | Solve the following coding problem using the programming language python:
Mysterious Chefland… Recently, Chef realised that Discuss, the educational system of Chefland, is out of date. Therefore, he is trying to find ways to update the infrastructure in the country. One possible way is to move all materials from Discuss to Discourse.
Chef will have access to Discourse if his knowledge and power become exactly equal to $N$ and $M$ respectively. Initially, he has power $1$ and knowledge $1$.
Chef can perform actions of the following types to improve his skills:
- solve a problem — increase his knowledge by $X$
- do a push-up — increase his power by $Y$
- install ShareChat to keep in touch with friends — increase both knowledge and power by $1$
Chef can only install ShareChat at most once. The remaining actions may be performed any number of times and the actions may be performed in any order.
Help Chef find out whether it is possible to move from Discuss to Discourse.
-----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 four space-separated integers $N$, $M$, $X$ and $Y$.
-----Output-----
For each test case, print a single line containing the string "Chefirnemo" if it is possible to reach the required knowledge and power or "Pofik" if it is impossible.
-----Constraints-----
- $1 \le T \le 1,000$
- $1 \le N, M, X, Y \le 10^9$
-----Subtasks-----
Subtask #1 (30 points): $1 \le N, M, X, Y \le 100$
Subtask #2 (70 points): original constraints
-----Example Input-----
5
2 2 1 2
11 10 5 9
11 11 5 9
12 11 5 9
1 2 1 100
-----Example Output-----
Chefirnemo
Chefirnemo
Pofik
Chefirnemo
Pofik
-----Explanation-----
Example case 2: We add $Y=9$ once to the power to get power $10$. We add $X=5$ twice to the knowledge to get knowledge $11$.
Example case 3: We can see that it is impossible to reach power $M=11$ no matter which or how many operations we do. Note that the ShareChat operation will increase both knowledge and power by $1$, and hence it will still be impossible to attain the given values of knowledge and power at the same time.
Example case 4: We can reach knowledge $11$ and power $10$ like in example case 2, the only difference is that we also use the ShareChat operation to increase both by $1$.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
t = input()
t = int(t)
for _ in range(t):
n, m, x, y = input().split()
n = int(n)
m = int(m)
x = int(x)
y = int(y)
n -= 1
m -= 1
flag = 0
if n % x == 0 and m % y == 0:
flag = 1
n -= 1
m -= 1
if n >= 0 and m >= 0:
if n % x == 0 and m % y == 0:
flag = 1
if flag == 1:
print("Chefirnemo")
else:
print("Pofik")
``` | {
"language": "python",
"test_cases": [
{
"input": "5\n2 2 1 2\n11 10 5 9\n11 11 5 9\n12 11 5 9\n1 2 1 100\n",
"output": "Chefirnemo\nChefirnemo\nPofik\nChefirnemo\nPofik\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/CHEFADV"
} | vfc_4426 |
apps | verifiable_code | 1397 | Solve the following coding problem using the programming language python:
Chef has a sequence $A_1, A_2, \ldots, A_N$. For a positive integer $M$, sequence $B$ is defined as $B = A*M$ that is, appending $A$ exactly $M$ times. For example, If $A = [1, 2]$ and $M = 3$, then $B = A*M = [1, 2, 1, 2, 1, 2]$
You have to help him to find out the minimum value of $M$ such that the length of the longest strictly increasing subsequence is maximum possible.
-----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 value of $M$.
-----Constraints-----
- $1 \le T \le 500$
- $1 \le N \le 2*10^5$
- $1 \le A_i \le 10^9$
- It's guaranteed that the total length of the sequence $A$ in one test file doesn't exceed $2*10^6$
-----Sample Input:-----
3
2
2 1
2
1 2
5
1 3 2 1 2
-----Sample Output:-----
2
1
2
-----Explanation:-----
In the first test case, Choosing $M = 2$ gives $B = [2, 1, 2, 1]$ which has a longest strictly increasing sequence of length $2$ which is the maximum possible.
In the second test case, Choosing $M = 1$ gives $B = [1, 2]$ which has a longest strictly increasing sequence of length $2$ which is the maximum possible.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
def mForMaxSeq(arr, n):
eim = dict()
for i in range(n):
if arr[i] in eim:
eim[arr[i]].append(i)
else:
eim[arr[i]] = [i]
keys = sorted(eim.keys())
# print(eim, keys)
connected = False
count = 0
pI = -1
nKeys = len(keys)
for i in range(nKeys-1):
if not connected:
pI = eim[keys[i]][0]
for idx in eim[keys[i+1]]:
if idx >pI:
connected = True
count += 1
pI = idx
break
else:
connected = False
for idx in eim[keys[i+1]]:
if idx > pI:
connected = True
count += 1
pI = idx
break
return (nKeys - count)
def __starting_point():
for _ in range(int(input())):
n = int(input())
arr = list(map(int, input().split()))
print(mForMaxSeq(arr, n))
__starting_point()
``` | {
"language": "python",
"test_cases": [
{
"input": "3\n2\n2 1\n2\n1 2\n5\n1 3 2 1 2\n",
"output": "2\n1\n2\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/RC122020/problems/RECNDROT"
} | vfc_4430 |
apps | verifiable_code | 1399 | Solve the following coding problem using the programming language python:
Recently, Chef found a new formula for computing powers of a sequence:
- You are given two sequences $A_1, A_2, \ldots, A_N$ and $(l_1, r_1), (l_2, r_2), \ldots, (l_N, r_N)$.
- The $1$-st power of the sequence $A$ is $A^1 = A$.
- For each $k > 1$, the $k$-th power of the sequence $A$ (denoted by $A^k$) is a sequence with length $N$ such that for each valid $i$, the $i$-th element of this sequence is (Ak)i=(Ak−1)li⊕(Ak−1)li+1⊕…⊕(Ak−1)ri−1⊕(Ak−1)ri.(Ak)i=(Ak−1)li⊕(Ak−1)li+1⊕…⊕(Ak−1)ri−1⊕(Ak−1)ri.(A^k)_i = (A^{k-1})_{l_i} \oplus (A^{k-1})_{l_i+1} \oplus \ldots \oplus (A^{k-1})_{r_i-1} \oplus (A^{k-1})_{r_i} \,.
After discovering this new formula, Chef tried to find $A^K$, but he felt that it is very time consuming. Therefore, Chef wants you to do it. Can you find the $K$-th power of $A$ for Chef?
-----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 $A_1, A_2, \ldots, A_N$.
- $N$ lines follow. For each valid $i$, the $i$-th of these lines contains two space-separated integers $l_i$ and $r_i$.
-----Output-----
For each test case, print a single line containing $N$ space-separated integers $(A^K)_1, (A^K)_2, \ldots, (A^K)_N$.
-----Constraints-----
- $1 \le T \le 3$
- $1 \le N \le 500$
- $1 \le K \le 5 \cdot 10^7$
- $1 \le A_i \le 10^{18}$ for each valid $i$
- $1 \le l_i \le r_i \le N$ for each valid $i$
-----Subtasks-----
Subtask #1 (50 points):
- $T = 1$
- $N \le 100$
Subtask #2 (50 points): original constraints
-----Sample Input-----
1
3 2
1 2 3
1 2
2 3
1 3
-----Example Ouput-----
3 1 0
-----Explanation-----
Example case 1:
- $(A^2)_1 = A_1 \oplus A_2 = 1 \oplus 2 = 3$
- $(A^2)_2 = A_2 \oplus A_3 = 2 \oplus 3 = 1$
- $(A^2)_3 = A_1 \oplus A_2 \oplus A_3 =1 \oplus 2 \oplus 3 = 0$
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
import numpy as np
def solve(n,k,a,l,r):
shape = (n,n)
mat = np.zeros(shape, dtype=np.int64)
for i in range(n):
for j in range(l[i], r[i]):
mat[i][j]=1
ans = np.eye(n,n, dtype=np.int64)
while(k>0):
if k%2 == 1:
ans = np.matmul(mat, ans)
ans%=2
mat = np.matmul(mat, mat)
mat%=2
k = k//2
result = []
for i in range(n):
aux = 0
for j in range(n):
if ans[i][j] == 1:
aux^=a[j]
result.append(aux)
return result
t = int(input())
for i in range(t):
s = input().split()
n = int(s[0])
k = int(s[1])
a = []
l = []
r = []
s = input().split()
for i in range(n):
a.append(int(s[i]))
for i in range(n):
s = input().split()
l.append(int(s[0])-1)
r.append(int(s[1]))
arr = solve(n,k-1,a,l,r)
s = ""
for e in arr:
s += str(e)
s +=" "
print(s)
``` | {
"language": "python",
"test_cases": [
{
"input": "1\n3 2\n1 2 3\n1 2\n2 3\n1 3\n",
"output": "3 1 0\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/HXR"
} | vfc_4438 |
apps | verifiable_code | 1400 | Solve the following coding problem using the programming language python:
Chandler has a list of non zero positive integers with him. He made a very interesting observation about the list. He noticed that the number of unique integers in an array of size $N$ is in the range $L$ to $R$ (both inclusive) and every element was either 1 or an even number x, in which case x/2 was also definitely present in the array.
Chandler has misplaced the list of integers but he wants to impress Monica with his problem solving skills by finding out the minimum and maximum possible sum of all elements of the list of integers.
Can you also help him solve the problem so that he can win over Monica?
-----Input:-----
- First line will contain $T$, the number of testcases.
- The first line of each test case contains integers $N$, $L$, and $R$.
-----Output:-----
For each test case print 2 space-separated integers, the minimum and the maximum possible sum of N elements based on the above facts.
-----Constraints-----
- $1 \leq T \leq 100$
- $1 \leq N \leq 1000$
- $1 \leq L \leq R \leq min(N,20)$
-----Sample Input:-----
2
4 2 2
5 1 5
-----Sample Output:-----
5 7
5 31
-----EXPLANATION:-----
-
Example 1: For an array of size 4, with minimum 2 unique integers and maximum 2 unique integers, the possible arrays are (1,1,1,2), (1,1,2,2), (1,2,2,2)
Out of these, the minimum possible sum of elements is 5(1+1+1+2) and maximum possible sum is 7(1+2+2+2)
-
Example 2: For an array of size 5, with minimum 1 unique integer and maximum 5 unique integers, minimum possible sum of elements is 5(1+1+1+1+1) and maximum possible sum is 31(1+2+4+8+16)
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())):
n,l,h=list(map(int,input().split()))
print(n-l+1+2**(l)-2,1+2**(h)-2+2**(h-1)*(n-h))
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n4 2 2\n5 1 5\n",
"output": "5 7\n5 31\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/ENNO2020/problems/ENCNOV"
} | vfc_4442 |
apps | verifiable_code | 1401 | Solve the following coding problem using the programming language python:
Give me Chocolate
Anushka wants to buy chocolates.there are many chocolates in front of her, tagged with their prices.
Anushka has only a certain amount to spend, and she wants to maximize the number of chocolates she buys with this money.
Given a list of prices and an amount to spend, what is the maximum number of chocolates Anushka can buy?
For example,
if prices =[1,2,3,4]
and Anushka has k=7 to spend, she can buy items [1,2,3] for 6 , or [3,4] for 7 units of currency. she would choose the first group of 3 items.
Input Format
The first line contains two integers, n and k , the number of priced chocolates and the amount Anushka has to spend.
The next line contains n space-separated integers prices[i]
Constraints
1<= n <= 105
1<= k <= 109
1<= prices[i] <= 109
A chocolate can't be bought multiple times.
Output Format
An integer that denotes the maximum number of chocolates Anushka can buy for her.
Sample Input
7 50
1 12 5 111 200 1000 10
Sample Output
4
Explanation
she can buy only 4 chocolatess at most. These chocolates have the following prices: 1, 12, 5, 10.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
n,k = map(int,input().split())
prices = list(map(int,input().split()))
prices.sort()
sum,cnt = 0, 0
for price in prices:
sum += price
if sum <= k: cnt += 1
else: break
print(cnt)
``` | {
"language": "python",
"test_cases": [
{
"input": "7 50\n1 12 5 111 200 1000 10\n",
"output": "4\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/COM12020/problems/CODE_01"
} | vfc_4446 |
apps | verifiable_code | 1402 | Solve the following coding problem using the programming language python:
Recently, Chef studied the binary numeral system and noticed that it is extremely simple to perform bitwise operations like AND, XOR or bit shift on non-negative integers, while it is much more complicated to perform arithmetic operations (e.g. addition, multiplication or division).
After playing with binary operations for a while, Chef invented an interesting algorithm for addition of two non-negative integers $A$ and $B$:
function add(A, B):
while B is greater than 0:
U = A XOR B
V = A AND B
A = U
B = V * 2
return A
Now Chef is wondering how fast this algorithm is. Given the initial values of $A$ and $B$ (in binary representation), he needs you to help him compute the number of times the while-loop of the algorithm is repeated.
-----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 string $A$.
- The second line contains a single string $B$.
-----Output-----
For each test case, print a single line containing one integer ― the number of iterations the algorithm will perform during addition of the given numbers $A$ and $B$.
-----Constraints-----
- $1 \le T \le 10^5$
- $1 \le |A|, |B| \le 10^5$
- $A$ and $B$ contain only characters '0' and '1'
- the sum of $|A| + |B|$ over all test cases does not exceed $10^6$
-----Subtasks-----
Subtask #1 (20 points): $|A|, |B| \le 30$
Subtask #2 (30 points):
- $|A|, |B| \le 500$
- the sum of $|A| + |B|$ over all test cases does not exceed $10^5$
Subtask #3 (50 points): original constraints
-----Example Input-----
3
100010
0
0
100010
11100
1010
-----Example Output-----
0
1
3
-----Explanation-----
Example case 1: The initial value of $B$ is $0$, so while-loop is not performed at all.
Example case 2: The initial values of $A$ and $B$ are $0_2 = 0$ and $100010_2 = 34$ respectively. When the while-loop is performed for the first time, we have:
- $U = 34$
- $V = 0$
- $A$ changes to $34$
- $B$ changes to $2 \cdot 0 = 0$
The while-loop terminates immediately afterwards, so it is executed only once.
Example case 3: The initial values of $A$ and $B$ are $11100_2 = 28$ and $1010_2 = 10$ respectively. After the first iteration, their values change to $22$ and $16$ respectively. After the second iteration, they change to $6$ and $32$, and finally, after the third iteration, to $38$ and $0$.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
def add(A, B):
cnt = 0
while B > 0:
U = A ^ B
B = (A & B) * 2
A = U
cnt += 1
return cnt
for _ in range(int(input())):
print(add(int(input(),2), int(input(), 2)))
``` | {
"language": "python",
"test_cases": [
{
"input": "3\n100010\n0\n0\n100010\n11100\n1010\n",
"output": "0\n1\n3\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/BINADD"
} | vfc_4450 |
apps | verifiable_code | 1403 | Solve the following coding problem using the programming language python:
Dhruvil has always been a studious person and will be completing his Engineering soon. He is always kneen about solving problems and is preparing hard for his next interview at Hackerrank. He has practiced lots of problems and now he came across this problem.
Given a message containing English letters(A-Z), it is being encoded to numbers using the following mapping:
'A' -> 1,'B' -> 2 ……………… 'Z' -> 26.
Now, given a non-empty string containing only digits, help Dhruvil determine the total number of ways to decode it.
While decoding you need to choose a substring of charachters and not a subsequence. Also a chosen substring should not contain any leading "0"s, but can contain trailing "0"s. Since the output can be very large print the answer as modulo 10^9 + 7 i.e 1000000007.
-----Input:-----
The first line of the input consists of single integer T, the number of test cases.
Each test case consists of a string.
-----Output:-----
For each test case print a single integer - the total number of ways to decode the digit string.
-----Constraints-----
- $1 \leq T \leq 1000$
- $2 \leq S \leq 10^9$
-----Sample Input:-----
2
12
226
-----Sample Output:-----
2
3
-----EXPLANATION:-----
There are 2 possible ways. It could be decoded as "AB" {1,2} or "L" {12}.
There are 3 possible ways. It could be decoded as "BZ" {2,26}, "VF" {22,6}, or "BBF" {2,2,6}.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
# cook your dish here
# cook your dish here
def numDec(s):
if not s:
return 0
dp = [0 for _ in range(len(s) + 1)]
dp[0] = 1
dp[1] = 0 if s[0] == '0' else 1
for i in range(2, len(dp)):
if s[i-1] != '0':
dp[i] += dp[i-1]
two_digit = int(s[i-2 : i])
if two_digit >= 10 and two_digit <= 26:
dp[i] += dp[i-2]
return dp[len(s)]
t = int(input())
while(t):
t-=1
s = input()
print(numDec(s)%1000000007)
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n12\n226\n",
"output": "2\n3\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/CEFT2020/problems/INTER"
} | vfc_4454 |
apps | verifiable_code | 1404 | Solve the following coding problem using the programming language python:
Today a plane was hijacked by a maniac. All the passengers of the flight are taken as hostage. Chef is also one of them.
He invited one of the passengers to play a game with him. If he loses the game, he will release all the passengers, otherwise he will kill all of them. A high risk affair it is.
Chef volunteered for this tough task. He was blindfolded by Hijacker. Hijacker brought a big black bag from his pockets. The contents of the bag is not visible. He tells Chef that the bag contains R red, G green and B blue colored balloons.
Hijacker now asked Chef to take out some balloons from the box such that there are at least K balloons of the same color and hand him over. If the taken out balloons does not contain at least K balloons of the same color, then the hijacker will shoot everybody. Chef is very scared and wants to leave this game as soon as possible, so he will draw the minimum number of balloons so as to save the passengers. Can you please help scared Chef to find out the minimum number of balloons he should take out.
-----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 three space-separated integers R, G and B.
The second line contains only one integer K.
-----Output-----
For each test case, output a single line containing one integer - the minimum number of balloons Chef need to take out from the bag.
-----Constraints-----
- 1 ≤ T ≤ 1000
- 1 ≤ R, G, B ≤ 109
- 1 ≤ K ≤ max{R, G, B}
-----Subtasks-----
- Subtask 1 (44 points): 1 ≤ R, G, B ≤ 10
- Subtask 2 (56 points): No additional constraints
-----Example-----
Input:
2
3 3 3
1
3 3 3
2
Output:
1
4
-----Explanation-----
Example case 2. In the worst-case scenario first three balloons will be of the three different colors and only after fourth balloon Chef will have two balloons of the same color. So, Chef might need to fetch 4 balloons
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
import sys
test_cases = int(input())
for i in range(0,test_cases):
count = input().split()
#print count
count_r = int(count[0])
count_g = int(count[1])
count_b = int(count[2])
k = int(input())
if k is 1:
total = 1
else:
total = 1
if count_r < k:
total = total + count_r
else:
total = total + (k-1)
if count_g < k:
total = total + count_g
else:
total = total + (k-1)
if count_b < k:
total = total + count_b
else:
total = total + (k-1)
print(total)
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n3 3 3\n1\n3 3 3\n2\n",
"output": "1\n4\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/APRIL16/problems/CHBLLNS"
} | vfc_4458 |
apps | verifiable_code | 1405 | Solve the following coding problem using the programming language python:
There are $N$ sabotages available in the game Among Us, initially all at level $0$.
$N$ imposters are allotted the task to upgrade the level of the sabotages.
The $i^{th}$ imposter $(1 \leq i \leq N)$ increases the level of $x^{th}$ sabotage $(1 \leq x \leq N)$ by one level if $gcd(i,x)=i$.
You need to find the number of sabotages at LEVEL 5 after all the imposters have completed their tasks.
-----Input:-----
- First line will contain $T$, number of testcases. Then the testcases follow.
- Each testcase contains of a single line of input, one integer $N$.
-----Output:-----
For each testcase, output in a single line the number of sabotages at LEVEL 5.
-----Constraints-----
- $1 \leq T \leq 10^5$
- $1 \leq N \leq 10^{18}$
-----Sample Input:-----
1
6
-----Sample Output:-----
0
-----EXPLANATION:-----
The $1^{st}$ sabotage is at level $1$, the $2^{nd}$, $3^{rd}$ and $5^{th}$ sabotages are at level $2$, the $4^{th}$ sabotage is at level $3$ and the $6^{th}$ sabotage is at level $4$.
None of them reach level $5$. 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
from bisect import bisect
n = 32000
def primeSeive(n):
prime = [True for i in range(n + 1)]
primes = []
p = 2
while (p * p <= n):
if (prime[p] == True):
for i in range(p * 2, n + 1, p):
prime[i] = False
p += 1
prime[0] = False
prime[1] = False
for p in range(n + 1):
if prime[p]:
primes.append(p)
return primes
arr = primeSeive(n)
fin = []
for i in arr:
fin.append(pow(i,4))
for _ in range(int(input())):
n = int(input())
print(bisect(fin,n))
``` | {
"language": "python",
"test_cases": [
{
"input": "1\n6\n",
"output": "0\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/RC152020/problems/REC15B"
} | vfc_4462 |
apps | verifiable_code | 1406 | Solve the following coding problem using the programming language python:
A sophomore Computer Science student is frustrated with boring college lectures. Professor X agreed to give him some questions; if the student answers all questions correctly, then minimum attendance criteria will not apply to him.
Professor X chooses a sequence $A_1, A_2, \ldots, A_N$ and asks $Q$ queries. In each query, the student is given an integer $P$; he has to construct a sequence $B_1, B_2, \ldots, B_N$, where $P \oplus A_i = B_i$ for each valid $i$ ($\oplus$ denotes bitwise XOR), and then he has to find the number of elements of this sequence which have an even number of $1$-s in the binary representation and the number of elements with an odd number of $1$-s in the binary representation. Help him answer the queries.
-----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 $N$ space-separated integers $A_1, A_2, \ldots, A_N$.
- $Q$ lines follow. Each of these lines contains a single integer $P$ describing a query.
-----Output-----
For each query, print a single line containing two space-separated integers ― the number of elements with an even number of $1$-s and the number of elements with an odd number of $1$-s in the binary representation.
-----Constraints-----
- $1 \le T \le 100$
- $1 \le N, Q \le 10^5$
- $ T \cdot (N+Q) \leq 4 \cdot 10^6 $
- $1 \le A_i \le 10^8$ for each valid $i$
- $1 \le P \le 10^5$
The input/output is quite large, please use fast reading and writing methods.
-----Subtasks-----
Subtask #1 (30 points): $N, Q \le 1,000$
Subtask #2 (70 points): original constraints
-----Example Input-----
1
6 1
4 2 15 9 8 8
3
-----Example Output-----
2 4
-----Explanation-----
Example case 1: The elements of the sequence $B$ are $P \oplus 4 = 7$, $P \oplus 2 = 1$, $P \oplus 15 = 12$, $P \oplus 9 = 10$, $P \oplus 8 = 11$ and $P \oplus 8 = 11$. The elements which have an even number of $1$-s in the binary representation are $12$ and $10$, while the elements with an odd number of $1$-s are $7$, $1$, $11$ and $11$.
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
for _ in range(int(stdin.readline())):
n, q = list(map(int, stdin.readline().split()))
arr = list(map(int, stdin.readline().split()))[:n]
od = ev = 0
for i in arr:
if bin(i).count('1')%2==0:
ev += 1
else:
od += 1
for _ in range(q):
p = int(stdin.readline())
if bin(p).count('1')%2==0:
stdout.write(str(ev) + " " + str(od) + "\n")
else:
stdout.write(str(od) + " " + str(ev) + "\n")
``` | {
"language": "python",
"test_cases": [
{
"input": "1\n6 1\n4 2 15 9 8 8\n3\n",
"output": "2 4\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/ENGXOR"
} | vfc_4466 |
apps | verifiable_code | 1407 | Solve the following coding problem using the programming language python:
You are given an empty grid with $N$ rows (numbered $1$ through $N$) and $M$ columns (numbered $1$ through $M$). You should fill this grid with integers in a way that satisfies the following rules:
- For any three cells $c_1$, $c_2$ and $c_3$ such that $c_1$ shares a side with $c_2$ and another side with $c_3$, the integers written in cells $c_2$ and $c_3$ are distinct.
- Let's denote the number of different integers in the grid by $K$; then, each of these integers should lie between $1$ and $K$ inclusive.
- $K$ should be minimum possible.
Find the minimum value of $K$ and a resulting (filled) grid. 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 and only line of each test case contains two space-separated integers $N$ and $M$.
-----Output-----
- For each test case, print $N+1$ lines.
- The first line should contain a single integer — the minimum $K$.
- Each of the following $N$ lines should contain $M$ space-separated integers between $1$ and $K$ inclusive. For each valid $i, j$, the $j$-th integer on the $i$-th line should denote the number in the $i$-th row and $j$-th column of the grid.
-----Constraints-----
- $1 \le T \le 500$
- $1 \le N, M \le 50$
- the sum of $N \cdot M$ over all test cases does not exceed $7 \cdot 10^5$
-----Subtasks-----
Subtask #1 (100 points): original constraints
-----Example Input-----
2
1 1
2 3
-----Example Output-----
1
1
3
1 1 2
2 3 3
-----Explanation-----
Example case 1: There is only one cell in the grid, so the only valid way to fill it is to write $1$ in this cell. Note that we cannot use any other integer than $1$.
Example case 2: For example, the integers written in the neighbours of cell $(2, 2)$ are $1$, $2$ and $3$; all these numbers are pairwise distinct and the integer written inside the cell $(2, 2)$ does not matter. Note that there are pairs of neighbouring cells with the same integer written in them, but this is OK.
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):
m,n = [int(d) for d in input().split()]
if m == 1:
arr = []
if n%4 == 0:
print(2)
arr = [[1,1,2,2]*(n//4)]
elif n%4 == 1:
if n == 1:
print(1)
arr = [[1]]
else:
print(2)
arr = [[1,1,2,2]*(n//4) + [1]]
elif n%4 == 2:
if n == 2:
print(1)
arr = [[1,1]]
else:
print(2)
arr = [[1,1,2,2]*(n//4) + [1,1]]
elif n%4 == 3:
print(2)
arr = [[1,1,2,2]*(n//4) + [1,1,2]]
elif m == 2:
if n%3 == 0:
print(3)
a1 = [1,2,3]*(n//3)
arr = [a1,a1]
elif n%3 == 1:
if n == 1:
print(1)
arr = [[1],[1]]
else:
print(3)
a1 = [1,2,3]*(n//3) + [1]
arr = [a1,a1]
elif n%3 == 2:
if n == 2:
print(2)
arr = [[1,2],[1,2]]
else:
print(3)
a1 = [1,2,3]*(n//3) + [1,2]
arr = [a1,a1]
elif m == 3:
if n == 1:
print(2)
arr = [[1],[1],[2]]
elif n == 2:
print(3)
arr = [[1,1],[2,2],[3,3]]
elif n == 3:
print(4)
arr = [[1,3,4],[4,2,1],[4,2,1]]
elif n == 4:
print(4)
arr = [[1,3,4,2],[4,2,1,3],[4,2,1,3]]
else:
if n%4 == 0:
print(4)
a1 = [1,3,4,2]*(n//4)
a2 = [4,2,1,3]*(n//4)
arr = [a1,a2,a2]
elif n%4 == 1:
print(4)
a1 = [1,3,4,2]*(n//4) + [1]
a2 = [4,2,1,3]*(n//4) + [4]
arr = [a1,a2,a2]
elif n%4 == 2:
print(4)
a1 = [1,3,4,2]*(n//4) + [1,3]
a2 = [4,2,1,3]*(n//4) + [4,2]
arr = [a1,a2,a2]
elif n%4 == 3:
print(4)
a1 = [1,3,4,2]*(n//4) + [1,3,4]
a2 = [4,2,1,3]*(n//4) + [4,2,1]
arr = [a1,a2,a2]
else:
if n == 1:
print(2)
a1 = [1,3,4,2]*(n//4) + [1]
a2 = [4,2,1,3]*(n//4) + [2]
arr = []
i = 0
j = 0
c = 0
c1 = 0
for i in range(m):
if j == 0 and c < 3:
arr.append(a1)
c = c + 1
if c == 2:
j = 1
c = 0
else:
arr.append(a2)
c1 = c1 + 1
if c1 == 2:
j = 0
c1 = 0
elif n == 2:
print(3)
arr = []
a1 = [1,1]
a2 = [2,2]
a3 = [3,3]
if m%3 == 1:
arr = [a1,a2,a3]*(m//3) + [a1]
elif m%3 == 2:
arr = [a1,a2,a3]*(m//3) + [a1,a2]
elif m%3 == 0:
arr = [a1,a2,a3]*(m//3)
else:
print(4)
if n%4 == 0:
a1 = [1,3,4,2]*(n//4)
a2 = [4,2,1,3]*(n//4)
arr = []
i = 0
j = 0
c = 0
c1 = 0
for i in range(m):
if j == 0 and c < 3:
arr.append(a1)
c = c + 1
if c == 2:
j = 1
c = 0
else:
arr.append(a2)
c1 = c1 + 1
if c1 == 2:
j = 0
c1 = 0
elif n%4 == 1:
a1 = [1,3,4,2]*(n//4) + [1]
a2 = [4,2,1,3]*(n//4) + [4]
arr = []
i = 0
j = 0
c = 0
c1 = 0
for i in range(m):
if j == 0 and c < 3:
arr.append(a1)
c = c + 1
if c == 2:
j = 1
c = 0
else:
arr.append(a2)
c1 = c1 + 1
if c1 == 2:
j = 0
c1 = 0
elif n%4 == 2:
a1 = [1,3,4,2]*(n//4) + [1,3]
a2 = [4,2,1,3]*(n//4) + [4,2]
arr = []
i = 0
j = 0
c = 0
c1 = 0
for i in range(m):
if j == 0 and c < 3:
arr.append(a1)
c = c + 1
if c == 2:
j = 1
c = 0
else:
arr.append(a2)
c1 = c1 + 1
if c1 == 2:
j = 0
c1 = 0
elif n%4 == 3:
a1 = [1,3,4,2]*(n//4) + [1,3,4]
a2 = [4,2,1,3]*(n//4) + [4,2,1]
arr = []
i = 0
j = 0
c = 0
c1 = 0
for i in range(m):
if j == 0 and c < 3:
arr.append(a1)
c = c + 1
if c == 2:
j = 1
c = 0
else:
arr.append(a2)
c1 = c1 + 1
if c1 == 2:
j = 0
c1 = 0
for i in range(m):
for j in range(n):
print(arr[i][j],end = " ")
print()
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n1 1\n2 3\n",
"output": "1\n1\n3\n1 1 2\n2 3 3\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/DIFNEIGH"
} | vfc_4470 |
apps | verifiable_code | 1408 | Solve the following coding problem using the programming language python:
Chef's loves his dog so much! Once his dog created two strings a and b each of length n consisting of digits 1 and 2, and even a problem about them!
Chef's Dog will tell by barking if a string x (also containing only digits 1 and 2 and with length N) is good or not by performing the following actions.
- It starts at first digit of the string, i.e. at i = 1.
- It can move from digit i to either i - 1 or i + 1 if xi equals 1 and the corresponding digits exist.
- It can move from digit i to either i - 2 or i + 2 if xi equals 2 and the corresponding digits exist.
- It must visit each digit exactly once.
- It must finish at the last digit (XN).
Chef's dog wants to make both the strings a and b good by choosing some subset S (possibly empty) of indices of set {1, 2, ..., n} and swapping each index i ϵ S between string a and b, i.e. swapping ai and bi. Can you find how many such subsets S exist out there? As the answer could be large, output it modulo 109 + 7.
-----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 contains string a.
The second line contains string b.
-----Output-----
For each test case, output a single line containing answer of the problem.
-----Constraints-----
- 1 ≤ T ≤ 20
- 1 ≤ |a| = |b| ≤ 105
- '1' ≤ ai, bi ≤ '2'
-----Subtasks-----
- Subtask #1 (30 points) |a|, |b| ≤ 10
- Subtask #2 (70 points) original constraints
-----Example-----
Input:
2
1111
2211
222
111
Output:
8
0
-----Explanation-----
Test case 1.
Possible subsets are:
{}, {1, 2}, {1, 2, 3}, {1, 2, 4}, {1, 2, 3, 4}, {3}, {4}, {3, 4}.
Test case 2. There are no possible sets S which can make both the strings good.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
mod = 10 ** 9 + 7
from collections import Counter
choice = {'1' : ['11', '21', '22'], '2' : ['11', '12', '21']}
def solve(a,b):
n = len(a)
if n == 1:
return 2
dp = Counter([('11', '11')])
for i in range(n-1):
new = Counter()
for x,y in (a[i], b[i]), (b[i], a[i]):
for p in choice[x]:
for q in choice[y]:
m = p[-1] + x
n = q[-1] + y
new[m,n] += dp[p,q]
new[m,n] %= mod
dp = new
ans = 0
for i in '11', '21', :
for j in '11', '21':
ans += dp[i,j]
return (ans * 2) % mod
t = int(input())
for _ in range(t):
a = input()
b = input()
print(solve(a,b))
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n1111\n2211\n222\n111\n",
"output": "8\n0\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/CHEFTWOS"
} | vfc_4474 |
apps | verifiable_code | 1409 | Solve the following coding problem using the programming language python:
Chef solved so many hard questions, now he wants to solve some easy problems for refreshment. Chef asks Cheffina for the new question. Cheffina challanges the chef to print the total number of 1's in the binary representation of N(natural number).
-----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^6$
- $1 \leq N \leq 10^6$
-----Sample Input:-----
2
2
5
-----Sample Output:-----
1
2
-----EXPLANATION:-----
For 1) Binary representation of 2 is 10. i.e. only one 1 present in it.
For 2) Binary representation of 5 is 101, i.e. two 1's present in it.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
for t in range(int(input())):
n=int(input())
print(bin(n).count("1"))
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n2\n5\n",
"output": "1\n2\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/PBK22020/problems/ITGUY25"
} | vfc_4478 |
apps | verifiable_code | 1410 | Solve the following coding problem using the programming language python:
Alice's school is planning to take some students from her class on a field trip. Alice is really excited about it. There are a total of S students in her class. But due to budget constraints, the school is planning to take only N students for the trip. These students will be picked randomly. And each student has equal chance of being picked.
Alice's friend circle has M students including her. Though she is excited about the field trip, she will enjoy it only if there are atleast K of her friends with her on the trip. She is wondering what are the chances of that happening. She needs your help. Tell her the probability that she will enjoy given that she goes on the trip.
-----Input:-----
First line of input contains a single integer T, the number of test cases.
Each test starts with a single line having 4 space separated integers, S, N, M and K.
-----Output:-----
For each test case, output a line containing the required probability. The answer will be accepted if the relative error is not more than 10-6.
-----Constraints:-----
1 ≤ T ≤ 100
1 ≤ S ≤ 1000
1 ≤ N ≤ S
1 ≤ M ≤ S
0 ≤ K < M
-----Example:-----Input:
3
10 10 5 3
10 4 6 4
3 2 2 1
Output:
1.000000
0.000000
0.500000
-----Explanation:-----Case #1:
Every student will be taken to the trip. So all her 4 friends will accompany her to the trip no matter what.
Case #2:
Alice wants 4 out of her 5 friends to come along with her which isn't possible because the school is willing to pick only 4 students for the trip.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
nCr = [[0 for x in range(1001)] for x in range(1001)]
for i in range (0,1001):
nCr[i][0]=1
nCr[i][i]=1
for i in range (1,1001):
for j in range (1,1001):
if i!=j:
nCr[i][j] = nCr[i-1][j] + nCr[i-1][j-1]
t=eval(input())
for rajarshisarkar in range(0,t):
s,n,m,k=list(map(int,input().split(' ')))
foo=0.000000
tot = float(nCr[s-1][n-1])
if s==n:
print("1.000000\n")
continue
if k>n:
print("0.000000\n")
continue
if m>n:
wola=n
else:
wola=m
for i in range(k,wola):
foo+= ((nCr[m-1][i])*(nCr[s-m][n-i-1]))
print("%f\n"% (float(foo/tot)))
``` | {
"language": "python",
"test_cases": [
{
"input": "3\n10 10 5 3\n10 4 6 4\n3 2 2 1\n",
"output": "1.000000\n0.000000\n0.500000\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/FTRIP"
} | vfc_4482 |
apps | verifiable_code | 1411 | Solve the following coding problem using the programming language python:
Motu and Patlu are racing against each other on a circular track of radius $R$. Initially they are at the same point on the track and will run in same direction .The coach ordered them to run $X$ rounds of the circular field. Patlu wants to know how many times they will meet after the race starts and before any of them finishes $X$ rounds. But he is busy in warm up so he wants you to calculate this. You are given speed of both Motu and Patlu ($A$ and $B$).
-----Input:-----
- First line will contain $T$, number of testcases. Then the testcases follow.
- Each testcase contains of a single line of input, four integers $X, R, A, B$.
-----Output:-----
For each testcase, output in a single line answer the number of times whey will meet before any of them completes $X$ rounds.
-----Constraints-----
- $1 \leq T \leq 1000$
- $1 \leq R \leq 10^9$
- $1 \leq X \leq 10^9$
- $1 \leq A \leq 10^9$
- $1 \leq B \leq 10^9$
- Speed of both are different
-----Sample Input:-----
2
3 10 2 5
2 20 5 10
-----Sample Output:-----
1
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
import math
def swap(a,b):
return b,a
t = int(input())
while(t!=0):
z = list(map(int,input().strip().split(" ")))
x=z[0]
r=z[1]
a=z[2]
b=z[3]
#p = math.pi
peri = 2*r
tp = x*peri
if(a<b):
a,b=swap(a,b)
t1 = tp/a
d2 = t1* b
dd = abs(tp-d2)
if(dd%peri==0):
print(int(dd//peri)-1)
else:
n = int(dd//peri)
print(n)
t-=1
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n3 10 2 5\n2 20 5 10\n",
"output": "1\n0\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/SMTC2020/problems/RROUNDS"
} | vfc_4486 |
apps | verifiable_code | 1412 | 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')
``` | {
"language": "python",
"test_cases": [
{
"input": "4\n2\n5 3\n3 1\n5\n0\n01800.00\n0\n0.00100\n3\nx 0\nd 3\n# .\n0xd21#dd098x\n\n\n",
"output": "3\n1800\n.001\n321.33098\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/FORGETPW"
} | vfc_4490 |
apps | verifiable_code | 1413 | Solve the following coding problem using the programming language python:
You are given a 1×1×2$1 \times 1 \times 2$ bar (a cuboid) and a grid A$A$ with N$N$ rows (numbered 1$1$ through N$N$) and M$M$ columns (numbered 1$1$ through M$M$). Let's denote the cell in row r$r$ and column c$c$ by (r,c)$(r, c)$. Some cells of the grid are blocked, the remaining cells are free.
Each cell has dimensions 1×1$1 \times 1$, the same as two opposite faces of the cuboid. When the bar is placed on the grid in such a way that one of its two 1×1$1 \times 1$ faces fully covers a cell (r,c)$(r, c)$, we say that the bar is standing on the cell (r,c)$(r, c)$. Initially, the bar is standing on a cell (x,y)$(x, y)$.
When the bar is placed on the grid, one of its faces is touching the grid; this face is called the base. In one move, you must roll the bar over one of its base edges (sides of the base); this base edge does not move and the bar is rotated 90∘$90^\circ$ around it in such a way that it is still lying on the grid, but with a different base. In different moves, the bar may be rotated around different edges in different directions. After each move, the base of the bar must lie fully inside the grid and it must not cover any blocked cells.
An example sequence of moves is shown here.
For each cell of the grid, determine the minimum number of moves necessary to achieve the state where the bar is standing on this cell or determine that it is impossible to achieve.
-----Input-----
- The first line of the input contains a single integer T$T$ denoting the number of test cases. The description of T$T$ test cases follows.
- The first line of each test case contains two space-separated integers N$N$ and M$M$.
- The second line contains two space-separated integers x$x$ and y$y$.
- N$N$ lines follow. For each i$i$ (1≤i≤N$1 \le i \le N$), the i$i$-th of these lines contains M$M$ integers Ai,1,Ai,2,…,Ai,M$A_{i, 1}, A_{i, 2}, \ldots, A_{i, M}$ (a string with length M$M$). For each valid i,j$i, j$, Ai,j=0$A_{i, j} = 0$ denotes that the cell (i,j)$(i, j)$ is blocked and Ai,j=1$A_{i, j} = 1$ denotes that it is free.
-----Output-----
For each test case, print N$N$ lines, each containing M$M$ space-separated integers. For each valid i,j$i, j$, the j$j$-th integer on the i$i$-th of these lines should denote the minimum number of moves necessary to have the bar stand on cell (i,j)$(i, j)$, or it should be −1$-1$ if it is impossible.
-----Constraints-----
- 1≤T≤50$1 \le T \le 50$
- 1≤N,M≤1,000$1 \le N, M \le 1,000$
- 1≤x≤N$1 \le x \le N$
- 1≤y≤M$1 \le y \le M$
- 0≤Ai,j≤1$0 \le A_{i, j} \le 1$ for each valid i,j$i, j$
- Ax,y=1$A_{x, y} = 1$
- the sum of N⋅M$N \cdot M$ over all test cases does not exceed 106$10^6$
-----Subtasks-----
Subtask #1 (15 points):
- x=1$x = 1$
- y=1$y = 1$
- Ai,j=1$A_{i, j} = 1$ for each valid i,j$i, j$
Subtask #2 (85 points): original constraints
-----Example Input-----
2
2 4
1 1
1111
0111
2 4
1 1
1111
0011
-----Example Output-----
0 -1 -1 2
-1 -1 -1 3
0 -1 -1 2
-1 -1 -1 -1
-----Explanation-----
Example case 1: Initially, the base of the bar occupies the cell (1,1)$(1, 1)$. After the first move, it occupies the cells (1,2)$(1, 2)$ and (1,3)$(1, 3)$. After the second move, it can occupy the cell (1,4)$(1, 4)$.
Alternatively, after the second move, it can occupy the cells (2,2)$(2, 2)$ and (2,3)$(2, 3)$, and after the third move, it can occupy the cell (2,4)$(2, 4)$.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
def issafe(r,c,r1,c1,graph):
if (graph[r][c] and graph[r1][c1]):
return True
return False
t=int(input())
for mmmmmm in range(t):
n,m=map(int,input().split())
x,y=map(int,input().split())
graph=[[False]*(m+2) for _ in range(n+2)]
cost_graph=[[[-1,-1,-1] for __ in range(m)] for _ in range(n)]
for i in range(n):
str1=input()
for j,val in enumerate(str1):
graph[i][j]=(val=='1')
x=x-1
y=y-1
set1=set()
set1.add((x,y,0))
cost_graph[x][y][0]=0
while(set1):
set2=set()
while(set1):
r,c,p=set1.pop()
new_cost=cost_graph[r][c][p]+1
if(p==0):
if issafe(r,c+1,r,c+2,graph):
if cost_graph[r][c+1][1]==-1 or cost_graph[r][c+1][1]>new_cost:
cost_graph[r][c+1][1]=new_cost
set2.add((r,c+1,1))
if issafe(r+1,c,r+2,c,graph):
if cost_graph[r+1][c][2]==-1 or cost_graph[r+1][c][2]>new_cost:
cost_graph[r+1][c][2]=new_cost
set2.add((r+1,c,2))
if issafe(r,c-2,r,c-1,graph):
if cost_graph[r][c-2][1]==-1 or cost_graph[r][c-2][1]>new_cost:
cost_graph[r][c-2][1]=new_cost
set2.add((r,c-2,1))
if issafe(r-2,c,r-1,c,graph):
if cost_graph[r-2][c][2]==-1 or cost_graph[r-2][c][2]>new_cost:
cost_graph[r-2][c][2]=new_cost
set2.add((r-2,c,2))
elif(p==1):
if issafe(r,c+2,r,c+2,graph):
if cost_graph[r][c+2][0]==-1 or cost_graph[r][c+2][0]>new_cost:
cost_graph[r][c+2][0]=new_cost
set2.add((r,c+2,0))
if issafe(r+1,c,r+1,c+1,graph):
if cost_graph[r+1][c][1]==-1 or cost_graph[r+1][c][1]>new_cost:
cost_graph[r+1][c][1]=new_cost
set2.add((r+1,c,1))
if issafe(r,c-1,r,c-1,graph):
if cost_graph[r][c-1][0]==-1 or cost_graph[r][c-1][0]>new_cost:
cost_graph[r][c-1][0]=new_cost
set2.add((r,c-1,0))
if issafe(r-1,c,r-1,c+1,graph):
if cost_graph[r-1][c][1]==-1 or cost_graph[r-1][c][1]>new_cost:
cost_graph[r-1][c][1]=new_cost
set2.add((r-1,c,1))
elif(p==2):
if issafe(r,c+1,r+1,c+1,graph):
if cost_graph[r][c+1][2]==-1 or cost_graph[r][c+1][2]>new_cost:
cost_graph[r][c+1][2]=new_cost
set2.add((r,c+1,2))
if issafe(r+2,c,r+2,c,graph):
if cost_graph[r+2][c][0]==-1 or cost_graph[r+2][c][0]>new_cost:
cost_graph[r+2][c][0]=new_cost
set2.add((r+2,c,0))
if issafe(r,c-1,r+1,c-1,graph):
if cost_graph[r][c-1][2]==-1 or cost_graph[r][c-1][2]>new_cost:
cost_graph[r][c-1][2]=new_cost
set2.add((r,c-1,2))
if issafe(r-1,c,r-1,c,graph):
if cost_graph[r-1][c][0]==-1 or cost_graph[r-1][c][0]>new_cost:
cost_graph[r-1][c][0]=new_cost
set2.add((r-1,c,0))
set1=set2
for _ in range(n):
for __ in range(m):
print(cost_graph[_][__][0],end=" ")
print()
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n2 4\n1 1\n1111\n0111\n2 4\n1 1\n1111\n0011\n\n",
"output": "0 -1 -1 2\n-1 -1 -1 3\n0 -1 -1 2\n-1 -1 -1 -1\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/ROLLBAR"
} | vfc_4494 |
apps | verifiable_code | 1414 | 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')
``` | {
"language": "python",
"test_cases": [
{
"input": "4 3 3\nMMF\nMMM\nFFM\nFFM\n2 F\n3 M\n1 M\n",
"output": "yes\nno\nyes\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/CDVA16/problems/CDVA1605"
} | vfc_4498 |
apps | verifiable_code | 1415 | Solve the following coding problem using the programming language python:
Given a string s. Can you make it a palindrome by deleting exactly one character? Note that size of the string after deletion would be one less than it was before.
-----Input-----
First line of the input contains a single integer T denoting number of test cases.
For each test case, you are given a single line containing string s.
-----Output-----
For each test case, print YES or NO depending on the answer of the problem.
-----Constraints-----
Subtask 1, 35 points
- 1 ≤ T ≤ 100
- 2 ≤ size of string s ≤ 1000
- String s contains lowercase English alphabets (ie. from 'a' to 'z').
Subtask 2, 65 points
- 2 ≤ size of string s ≤ 10^5
- Sum of size of string s over all the input test cases won't exceed 10^6
- String s contains lowercase English alphabets (ie. from 'a' to 'z').
-----Example-----
Input:
4
aaa
abc
abdbca
abba
Output:
YES
NO
YES
YES
-----Explanation-----
Example case 1. Delete any one 'a', resulting string is "aa" which is a palindrome.
Example case 2. It is not possible to delete exactly one character and having a palindrome.
Example case 3. Delete 'c', resulting string is "abdba" which is a palindrome.
Example case 4. Delete 'b', resulting string is "aba" which is a palindrome.
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=str(input())
n=len(s)
k=s[::-1]
a,b="",""
for i in range(n):
if s[i]!=k[i]:
a+=s[i+1:]
b+=k[i+1:]
break
else:
a+=s[i]
b+=k[i]
#print(a,b)
if a==a[::-1] or b==b[::-1]:
print("YES")
else:
print("NO")
``` | {
"language": "python",
"test_cases": [
{
"input": "4\naaa\nabc\nabdbca\nabba\n",
"output": "YES\nNO\nYES\nYES\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/PRPALN"
} | vfc_4502 |
apps | verifiable_code | 1416 | Solve the following coding problem using the programming language python:
Han Solo and Chewbacca start a space journey to planet Naboo on the Millennium Falcon. During the journey they land at a mysterious planet with high gravity where they find n diamond stones scattered all around. All the stones are of same weight. Each stone has a value according to its purity which can be detected by a special device. They choose to divide the stones fairly among themselves in two halves so that they carry almost equal weights such that the difference between the value of two halves is as small as possible. If n is even, then sizes of two halves must be strictly n/2 and if n is odd, then size of one half must be (n-1)/2 and size of the other half must be (n+1)/2. Given the value of stones, help them to divide the stones among themselves.
-----Input-----
First line consists of an integer n which denotes the number of stones.Second line consists of n space separated integers denoting the value of the stones.
-----Output-----
First line consists of the values of the stones assigned to Han Solo.Second line consists of the values of the stones assigned to Chewbacca.Assume that the set containing the first value in the input is always assigned to Han Solo.Also the values in the output sets must follow the same ordering as the input.
-----Constraints-----
The number of stones can range from 2 to 99.The values of the stones vary from 1 to 10^4.
-----Example-----
Input:
7
1 2 3 4 5 6 7
Output:
1 2 4 7
3 5 6
-----Explanation-----
These 7 values must be separated into 2 sets of sizes 3 and 4.In this case, it is possible to form two sets (1,2,4,7) & (3,5,6) of equal size.The set containing the first value (i.e.) 1 must be assigned to Han Solo and the elements of the output sets have the same order as the input.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
s,n,s1,lis,new1=[],[],[],[],[]
import itertools
q = int(input())
s.append(input().split(' '))
s1 = list([list(map(int,x)) for x in s])
sum1 = sum(s1[0])
if len(s1[0])%2!=0 :
z = (len(s1[0])+1)//2
n = list(itertools.combinations(s1[0],z))
for j in range(len(n)) :
x = sum(n[j])
if x==sum1//2 :
lis = n[j]
break
new1 = list(lis)
sum2 = sum(new1)
for j in range(len(lis)) :
y = lis[j]
s1[0].remove(y)
sum3=sum(s1[0])
if sum3>sum2 :
print(' '.join(map(str,s1[0])))
print(' '.join(map(str,new1)))
else :
print(' '.join(map(str,new1)))
print(' '.join(map(str,s1[0])))
else :
z = len(s1[0])//2
n = list(itertools.combinations(s1[0],z))
for j in range(len(n)) :
x = sum(n[j])
if x==sum1//2 :
lis = n[j]
break
#print lis,len(lis)
new1 = list(lis)
sum2 = sum(new1)
for j in range(len(lis)) :
y = lis[j]
s1[0].remove(y)
sum3 = sum(s1[0])
if sum3>sum2 :
print(' '.join(map(str,s1[0])))
print(' '.join(map(str,new1)))
else :
print(' '.join(map(str,new1)))
print(' '.join(map(str,s1[0])))
``` | {
"language": "python",
"test_cases": [
{
"input": "7\n1 2 3 4 5 6 7\n",
"output": "1 2 4 7\n3 5 6\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/SOPC2015/problems/SOPC1504"
} | vfc_4506 |
apps | verifiable_code | 1418 | Solve the following coding problem using the programming language python:
You are given a sequence $A_1, A_2, \ldots, A_N$. You may perform the following operation an arbitrary number of times (including zero): choose two adjacent elements of this sequence, i.e. $A_i$, $A_{i+1}$ for some valid $i$, and swap them. However, for each valid $i$, it is not allowed to choose $A_i$ (the element with the index $i$, regardless of its value at any point in time) more than once in total during this process.
Find the maximum of the sum $S = \sum_{i=1}^N A_i \cdot i$.
-----Input-----
- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
- The first line of each test case contains a single integer $N$.
- The second line contains $N$ space-separated integers $A_1, A_2, \ldots, A_N$.
-----Output-----
For each test case, print a single line containing one integer ― the maximum possible value of $S$.
-----Constraints-----
- $1 \le T \le 1,000$
- $1 \le N \le 10^5$
- $1 \le A_i \le 10^9$ for each valid $i$
- the sum of $N$ over all test cases does not exceed $10^6$
-----Subtasks-----
Subtask #1 (50 points):
- $N \le 20$
- the sum of $N$ over all test cases does not exceed $200$
Subtask #2 (50 points): original constraints
-----Example Input-----
2
4
2 1 4 3
4
7 6 3 2
-----Example Output-----
30
39
-----Explanation-----
Example case 1: Swap the first and second element of the initial sequence. Then, swap the third and fourth element of the resulting sequence. The final sequence $A$ is $(1, 2, 3, 4)$.
Example case 2: Swap the second and third element to make the sequence $(7, 3, 6, 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
# cook your dish here
for _ in range(int(input())):
n=int(input())
l=list(map(int, input().split()))
l.insert(0, 0)
l1=[0]*(n+1)
l1[1]=l[1]
for i in range(2, n+1):
l1[i]=max(l1[i-1]+l[i]*i, l1[i-2]+l[i-1]*i+l[i]*(i-1))
print(l1[-1])
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n4\n2 1 4 3\n4\n7 6 3 2\n",
"output": "30\n39\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/SFRV"
} | vfc_4514 |
apps | verifiable_code | 1419 | Solve the following coding problem using the programming language python:
Mr. Wilson was planning to record his new Progressive Rock music album called "Digits. Cannot. Separate". Xenny and PowerShell, popular pseudo-number-theoreticists from the Land of Lazarus were called by him to devise a strategy to ensure the success of this new album. Xenny and Powershell took their Piano Lessons and arrived at the Studio in different Trains.
Mr. Wilson, creative as usual, had created one single, long music track S. The track consisted of N musical notes. The beauty of each musical note was represented by a decimal digit from 0 to 9.
Mr. Wilson told them that he wanted to create multiple musical tracks out of this long song. Since Xenny and Powershell were more into the number theory part of music, they didn’t know much about their real workings. Mr. Wilson told them that a separator could be placed between 2 digits. After placing separators, the digits between 2 separators would be the constituents of this new track and the number formed by joining them together would represent the Quality Value of that track. He also wanted them to make sure that no number formed had greater than M digits.
Mr. Wilson had Y separators with him. He wanted Xenny and PowerShell to use at least X of those separators, otherwise he would have to ask them to Drive Home.
Xenny and PowerShell knew straight away that they had to put place separators in such a way that the Greatest Common Divisor (GCD) of all the Quality Values would eventually determine the success of this new album. Hence, they had to find a strategy to maximize the GCD.
If you find the maximum GCD of all Quality Values that can be obtained after placing the separators, Xenny and PowerShell shall present you with a Porcupine Tree.
Note:
-
You can read about GCD here.
-
Greatest Common Divisor of 0 and 0 is defined as 0.
-----Input-----
The first line of input consists of a single integer T - the number of testcases.
Each test case is of the following format:
First line contains a single integer N - the length of the long musical track.
Second line contains the string of digits S.
Third line contains 3 space-separated integers - M, X and Y - the maximum number of digits in a number, the minimum number of separators to be used and the maximum number of separators to be used.
-----Output-----
For each testcase, output a single integer on a new line - the maximum GCD possible after placing the separators.
-----Constraints-----
Subtask 1: 20 points
- 1 ≤ T ≤ 10
- 1 ≤ N ≤ 18
- 1 ≤ M ≤ 2
- 1 ≤ X ≤ Y ≤ (N - 1)
Subtask 2: 80 points
- 1 ≤ T ≤ 10
- 1 ≤ N ≤ 300
- 1 ≤ M ≤ 10
- 1 ≤ X ≤ Y ≤ (N - 1)
For both Subtask 1 and Subtask 2:
- 1 ≤ X ≤ Y ≤ (N - 1)
- M*(Y+1) ≥ N
- S may contain leading 0s.
-----Example-----Input:
2
3
474
2 1 1
34
6311861109697810998905373107116111
10 4 25
Output:
2
1
-----Explanation-----
Test case 1.
Since only 1 separator can be placed, we can only have 2 possibilities:
a. 4 | 74
The GCD in this case is 2.
b. 47 | 4
The GCD in this case is 1.
Hence, the maximum GCD is 2.
Test case 2.
One of the optimal partitions is:
63|118|61|109|69|78|109|98|90|53|73|107|116|111
Bonus: Decode the above partition to unlock a hidden treasure.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
t = int(input())
def gcd (a, b):
if (b == 0): return a
return gcd (b, a % b)
dp = {}
def solve (p, k, g, s, m, x, y, n):
if ((p, k, g) in dp): return dp[(p, k, g)];
ans = 0
if (p == n):
if k >= x and k <= y:
ans = g
else:
ans = 0
else:
for i in range (p, n):
if (i - p + 1 > m): break
temp = solve (i + 1, k + 1, gcd(g, int(s[p:i + 1])), s, m, x, y, n)
if (temp > ans):
ans = temp
dp[(p, k, g)] = ans
return ans
while t != 0:
dp = {}
t -= 1
n = int(input())
s = input()
m, x, y = list(map (int, input().split()))
x += 1
y += 1
print(solve (0, 0, 0, s, m, x, y, n))
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n3\n474\n2 1 1\n34\n6311861109697810998905373107116111\n10 4 25\n",
"output": "2\n1\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/DIGITSEP"
} | vfc_4518 |
apps | verifiable_code | 1420 | Solve the following coding problem using the programming language python:
In an array, a $block$ is a maximal sequence of identical elements. Since blocks are maximal, adjacent blocks have distinct elements, so the array breaks up into a series of blocks. For example, given the array $[3, 3, 2, 2, 2, 1, 5, 8, 4, 4]$, there are 6 blocks: $[3, 3], [2, 2, 2], [1], [5], [8], [4, 4]$ .
In this task, you are given two arrays, $A$ (of length $n$), and $B$ (of length $m$), and a number $K$. You have to interleave $A$ and $B$ to form an array $C$ such that $C$ has $K$ blocks. Each way of interleaving $A$ and $B$ can be represented as a $0-1$ array $X$ of length $n+m$ in which $X[j]$ is $0$ if $C[j]$ came from $A$ and $X[j]$ is $1$ if $C[j]$ came from $B$.
A formal description of the interleaving process is given at the end.
For example, if $A = [1, 3]$ and $B = [3, 4]$, there are $6$ ways of interleaving $A$ and $B$. With each interleaving $X$ of $A$ and $B$, we also count the number of blocks in the resulting interleaved array $C$. The descriptions of the interleavings, $X$, and the outcomes, $C$, are given below.
- $X = [0, 0, 1, 1]$, which corresponds to $C = [1, 3, 3, 4]$, $3$ blocks.
- $X = [0, 1, 0, 1]$, which corresponds to $C = [1, 3, 3, 4]$, $3$ blocks.
- $X = [0, 1, 1, 0]$, which corresponds to $C = [1, 3, 4, 3]$ , $4$ blocks.
- $X = [1, 0, 0, 1]$, which corresponds to $C = [3, 1, 3, 4]$, $4$ blocks.
- $X = [1, 0, 1, 0]$, which corresponds to $C = [3, 1, 4, 3]$, $4$ blocks.
- $X = [1, 1, 0, 0]$, which corresponds to $C = [3, 4, 1, 3]$, $4$ blocks.
Observe that different interleavings $X$ may produce the same array $C$, such as the first two interleavings in the example above.
Your task is the following. Given arrays $A$ and $B$ and a number $K$, find the number of different interleavings $X$ of $A$ and $B$ that produce an output array $C$ with exactly $K$ blocks. Note that we are counting the number of interleavings, not the number of different output arrays after interleaving. For instance, if the same output array C is produced via 2 different interleavings, it gets counted twice.
Since the answer might be large, print the answer modulo $10^8 + 7$.
Here is a formal definition of the interleaving process:
Suppose $A = A_1, A_2, ..., A_n$ and $B = B_1, B_2, ..., B_m$. Then, the process of generating an interleaving $C$ can be described using an array $X$ of size $n + m$, with exactly $n$ $0's$ and $m$ $1's$. Suppose we have such an array $X = X_1, X_2, ..., X_{n+m}$. Using this array $X$, we create the output array $C = C_1, C_2, ..., C_{n+m}$, using the following algorithm:
i = 0, j = 0
while( (i+j)<(n+m) )
if(X[i+j+1] == 0)
C[i+j+1] = A[i+1]
i = i+1
else
C[i+j+1] = B[j+1]
j = j+1
Thus if the $X$ value is $0$, we pick the next available element from $A$ into $C$, and if it is $1$, we pick from $B$ instead. This creates an interleaving of the arrays $A$ and $B$.
-----Input Format:-----
- The first line contains a single integer, $T$, which is the number of testcases. The description of each testcase follows.
- The first line of each testcase contains three integers: $n$, $m$, and $K$, which denote the size of array $A$, the size of array $B$, and the required number of blocks in $C$, respectively.
- The next line contains $n$ integers, which represent the array $A$.
- The next line contains $m$ integers, which represent the array $B$.
-----Output Format:-----
- You should print the answer in a new line for each testcase, which should be the number of valid interleaving arrays $X$ which correspond to an output array $C$ with $K$ blocks, modulo $10^8 + 7$.
-----Constraints:-----
- $1 \leq T \leq 10$
- $1 \leq n \leq 100$
- $1 \leq m \leq 100$
- $1 \leq K \leq n+m$
- $0 \leq A_i, B_j \leq 10^9$
-----Subtasks:-----
- Subtask 1: 10% points: $m = 1$
- Subtask 2: 30% points: $0 \leq A_i, B_j \leq 1$
- Subtask 3: 60% points: Original constraints.
-----Sample Input:-----
5
2 2 4
1 3
3 4
2 2 3
1 3
3 4
2 2 2
1 3
3 4
2 2 4
4 7
8 5
2 2 2
4 7
8 5
-----Sample Output:-----
4
2
0
6
0
-----Explanation:-----
- The first three testcases correspond to the example given in the problem statement. Of the $6$ interleavings, $4$ produce outputs with $4$ blocks and $2$ produce outputs with $3$ blocks. Hence, for $K = 4$, the answer is $4$, for $K = 3$, the answer is $2$, and for $K = 2$, the answer is $0$.
- The fourth and fifth testcases have $A = [4, 7]$ and $B = [8, 5]$. Here are the $6$ interleavings of these two arrays.
- $X = [0, 0, 1, 1]$, which corresponds to $C= [4, 7, 8, 5]$, $4$ blocks.
- $X = [0, 1, 0, 1]$, which corresponds to $C= [4, 8, 7, 5]$, $4$ blocks.
- $X = [0, 1, 1, 0]$, which corresponds to $C= [4, 8, 5, 7]$, $4$ blocks.
- $X = [1, 0, 0, 1]$, which corresponds to $C= [8, 4, 7, 5]$, $4$ blocks.
- $X = [1, 0, 1, 0]$, which corresponds to $C= [8, 4, 5, 7]$, $4$ blocks.
- $X = [1, 1, 0, 0]$, which corresponds to $C= [8, 5, 4, 7]$, $4$ blocks.
All $6$ interleavings produce outputs with $4$ blocks, so for $K = 4$ the answer is $6$ and for any other value of $K$, 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
# cook your dish here
# cook your dish here
n=0;m=0;
A=[];B=[];
anscount=0;k=0;
def generate(n,m,l):
nonlocal anscount
if(len(l)==n+m):
X=l
i,j = 0,0
C=[0 for t in range(n+m)]
while((i+j)<(n+m)):
if(X[i+j] == 0):
C[i+j] = A[i]
i = i+1
else:
C[i+j] = B[j]
j = j+1
ans = len(C)
for i in range(1,len(C)):
if(C[i]==C[i-1]):
ans-=1
if(ans==k):
anscount+=1
else:
if(l.count(1)<m):
generate(n,m,l+[1])
if(l.count(0)<n):
generate(n,m,l+[0])
else:
if(l.count(0)<n):
generate(n,m,l+[0])
for _ in range(int(input())):
anscount=0
n,m,k=list(map(int,input().split()))
A=list(map(int,input().split()))
B=list(map(int,input().split()))
generate(n,m,[])
print(anscount)
``` | {
"language": "python",
"test_cases": [
{
"input": "5\n2 2 4\n1 3\n3 4\n2 2 3\n1 3\n3 4\n2 2 2\n1 3\n3 4\n2 2 4\n4 7\n8 5\n2 2 2\n4 7\n8 5\n",
"output": "4\n2\n0\n6\n0\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/ZCOPRAC/problems/ZCO20002"
} | vfc_4522 |
apps | verifiable_code | 1421 | Solve the following coding problem using the programming language python:
Patlu has recently got a new problem based on Pallindromes. A Pallindrome is a number that is same from front and back, example $121$ is pallindrome but $123$ is not . He wants to calculate sum of all $N$ digit number which are Pallindromic in nature and divisible by $9$ and does not contain any zero in their decimal representation. As the answer can be very large so print the sum modulo $10^9 + 7$.
-----Input:-----
- First line of input contain $T$, number of testcases. Then the testcases follow.
- Each testcase contains single line of input , one integer $N$.
-----Output:-----
- For each testcase, output in a single line answer having $N$ digits pallindromic string.
-----Constraints-----
- $1\leq T \leq 100$
- $1\leq N \leq 10^5$
-----Sample Input:-----
2
1
2
-----Sample Output:-----
9
99
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
def getsum(N):
if N==1:
return 9
if N==2:
return 99
s = ""
for i in range(0,N):
s = s+'5'
s = int(s)
if N%2==0:
s = s*pow(9,N//2-1)
else:
s = s*pow(9,N//2)
return s%(pow(10,9)+7)
def main():
t = int(input())
for _ in range(0,t):
N = int(input())
result = getsum(N)
print(result)
def __starting_point():
main()
__starting_point()
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n1\n2\n",
"output": "9\n99\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/CCOD2020/problems/PALL9"
} | vfc_4526 |
apps | verifiable_code | 1422 | Solve the following coding problem using the programming language python:
The Little Elephant from the Zoo of Lviv currently is on the military mission. There are N enemy buildings placed in a row and numbered from left to right strating from 0. Each building i (except the first and the last) has exactly two adjacent buildings with indices i-1 and i+1. The first and the last buildings have just a single adjacent building.
Some of the buildings contain bombs. When bomb explodes in some building it destroys it and all adjacent to it buildings.
You are given the string S of length N, where Si is 1 if the i-th building contains bomb, 0 otherwise. Find for the Little Elephant the number of buildings that will not be destroyed after all bombs explode. Please note that all bombs explode simultaneously.
-----Input-----
The first line contains single integer T - the number of test cases. T test cases follow. The first line of each test case contains the single integer N - the number of buildings. The next line contains the string S of length N consisted only of digits 0 and 1.
-----Output-----
In T lines print T inetgers - the answers for the corresponding test cases.
-----Constraints-----
1 <= T <= 100
1 <= N <= 1000
-----Example-----
Input:
3
3
010
5
10001
7
0000000
Output:
0
1
7
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
import sys
T = int(sys.stdin.readline().strip())
for t in range(T):
sys.stdin.readline().strip()
st = '0'+sys.stdin.readline().strip()+'0'
res = 0
for i in range(1,len(st)-1):
if st[i] == st[i-1] == st[i+1] == '0':
res+=1
print(res)
``` | {
"language": "python",
"test_cases": [
{
"input": "3\n3\n010\n5\n10001\n7\n0000000\n",
"output": "0\n1\n7\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/AUG12/problems/LEBOMBS"
} | vfc_4530 |
apps | verifiable_code | 1423 | Solve the following coding problem using the programming language python:
Vlad enjoys listening to music. He lives in Sam's Town. A few days ago he had a birthday, so his parents gave him a gift: MP3-player! Vlad was the happiest man in the world! Now he can listen his favorite songs whenever he wants!
Vlad built up his own playlist. The playlist consists of N songs, each has a unique positive integer length. Vlad likes all the songs from his playlist, but there is a song, which he likes more than the others. It's named "Uncle Johny".
After creation of the playlist, Vlad decided to sort the songs in increasing order of their lengths. For example, if the lengths of the songs in playlist was {1, 3, 5, 2, 4} after sorting it becomes {1, 2, 3, 4, 5}. Before the sorting, "Uncle Johny" was on K-th position (1-indexing is assumed for the playlist) in the playlist.
Vlad needs your help! He gives you all the information of his playlist. Your task is to find the position of "Uncle Johny" in the sorted playlist.
-----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 one integer N denoting the number of songs in Vlad's playlist. The second line contains N space-separated integers A1, A2, ..., AN denoting the lenghts of Vlad's songs.
The third line contains the only integer K - the position of "Uncle Johny" in the initial playlist.
-----Output-----
For each test case, output a single line containing the position of "Uncle Johny" in the sorted playlist.
-----Constraints-----
1 ≤ T ≤ 1000
1 ≤ K ≤ N ≤ 100
1 ≤ Ai ≤ 109
-----Example-----
Input:
3
4
1 3 4 2
2
5
1 2 3 9 4
5
5
1 2 3 9 4
1
Output:
3
4
1
-----Explanation-----
In the example test there are T=3 test cases.
Test case 1
In the first test case N equals to 4, K equals to 2, A equals to {1, 3, 4, 2}. The answer is 3, because {1, 3, 4, 2} -> {1, 2, 3, 4}. A2 now is on the 3-rd position.
Test case 2
In the second test case N equals to 5, K equals to 5, A equals to {1, 2, 3, 9, 4}. The answer is 4, because {1, 2, 3, 9, 4} -> {1, 2, 3, 4, 9}. A5 now is on the 4-th position.
Test case 3
In the third test case N equals to 5, K equals to 1, A equals to {1, 2, 3, 9, 4}. The answer is 1, because {1, 2, 3, 9, 4} -> {1, 2, 3, 4, 9}. A1 stays on the 1-th position.
-----Note-----
"Uncle Johny" is a real song performed by The Killers.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
# cook your dish here
t=int(input())
for i in range(t):
n=int(input())
nums=list(map(int,input().split()))
k=int(input())
an=nums[k-1]
cn=0
for i in range(n):
if(nums[i]<an):
cn+=1
print(cn+1)
``` | {
"language": "python",
"test_cases": [
{
"input": "3\n4\n1 3 4 2\n2\n5\n1 2 3 9 4\n5\n5\n1 2 3 9 4 \n1\n\n\n",
"output": "3\n4\n1\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/JOHNY"
} | vfc_4534 |
apps | verifiable_code | 1424 | Solve the following coding problem using the programming language python:
Little Praneet loves experimenting with algorithms and has devised a new algorithm. The algorithm is performed on an integer as follows:
- if the rearmost digit is $0$, he will erase it.
- else, he will replace the rearmost digit $d$ with $d-1$.
If a point comes when the integer becomes $0$, the algorithm stops.
You are given an integer $n$. Praneet will perform the algorithm on it $a$ times. You have to print the result after $a$ operations.
-----Input:-----
- The first and only line of input contains two integers $n$ — initial number, and $a$ —the number of operations.
-----Output:-----
- Print one integer — the result of performing the algorithm on $n$ $a$ times.
-----Constraints-----
- $2 \leq n \leq 10^9$
- $1 \leq a \leq 50$
-----Sample Input 1-----
1001 2
-----Sample Input 2-----
5 2
-----Sample Output 1-----
100
-----Sample Output 2-----
3
-----Explanation-----
- In the first example, the transformation is as follows: $1001->1000->100$.
- In the second example, the transformation is as follows: $5->4->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
n,a=map(int,input().split())
for i in range(a):
if(n%10==0):
n=n//10
else:
n=n-1
print(n)
``` | {
"language": "python",
"test_cases": [
{
"input": "1001 2\nSample Input 2\n5 2\n",
"output": "100\nSample Output 2\n3\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/COTH2020/problems/SUBALGO"
} | vfc_4538 |
apps | verifiable_code | 1425 | Solve the following coding problem using the programming language python:
Chef has just learned a new data structure - Fenwick tree. This data structure holds information about array of N elements and can process two types of operations:
- Add some value to ith element of the array
- Calculate sum of all elements on any prefix of the array
Both operations take O(log N) time. This data structure is also well known for its low memory usage. To be more precise, it needs exactly the same amount of memory as that of array.
Given some array A, first we build data structure in some other array T. Ti stores the sum of the elements Astart, Astart + 1, ..., Ai. Index start is calculated with formula start = Fdown(i) = (i & (i + 1)). Here "&" denotes bitwise AND operation.
So, in order to find a sum of elements A0, A1, ..., AL you start with index L and calculate sum of TL + TFdown(L)-1 + TFdown(Fdown(L)-1)-1 + ... + TFdown(Fdown(...(Fdown(L)-1)-1)-1. Usually it is performed with cycle that goes from L down to 0 with function Fdown and sums some elements from T. Chef wants to verify that the time complexity to calculate sum of A0, A1, A2, ..., AL is O(log L). In order to do so, he wonders how many times he has to access array T to calculate this sum. Help him to find this out.
Since Chef works with really big indices. The value of L can be very large and is provided to you in binary representation as concatenation of strings L1, L2 repeated N times and string L3.
-----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 three non-empty strings L1, L2, L3 and an integer N. Strings will contain only characters 0 and 1. To obtain binary representation of index L concatenate L1 with L2 repeated N times and with L3. You are guaranteed that the index will be positive.
-----Output-----
For each test case, output a single line containing number of times Fenwick tree data structure will access array T in order to compute sum of A0, A1, A2, ..., AL.
-----Constraints-----
- 1 ≤ T ≤ 300
- 1 ≤ Length(Li) ≤ 1000
- 1 ≤ N ≤ 106
-----Subtasks-----
- Subtask #1 (20 points): |L1| + |L2| * N + |L3| ≤ 60
- Subtask #2 (30 points): 1 ≤ T ≤ 30, 1 ≤ N ≤ 100
- Subtask #3 (50 points): No additional constraints
-----Example-----
Input:
4
001 100 011 4
1000 1101 100 3
1010 001 101 4
010 101 000 4
Output:
6
12
8
10
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())
count=[]
for i in range(t) :
s = input()
a,b,c,n = s.split()
n=int(n)
d = int(a+b*n+c,2)
count.append(0)
while(d>0) :
d=(d&(d+1))-1
count[i]+=1
for i in range(t) :
print(count[i])
``` | {
"language": "python",
"test_cases": [
{
"input": "4\n001 100 011 4\n1000 1101 100 3\n1010 001 101 4\n010 101 000 4\n",
"output": "6\n12\n8\n10\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/FENWITER"
} | vfc_4542 |
apps | verifiable_code | 1426 | Solve the following coding problem using the programming language python:
Chef is operating a slush machine. The machine produces slush drinks with $M$ flavors (numbered $1$ through $M$); for each valid $i$, the maximum number of drinks with flavour $i$ the machine can produce is $C_i$.
Chef expects $N$ customers to come buy slush drinks today. The customers are numbered $1$ through $N$ in the order in which they buy the drinks. For each valid $i$, the favorite flavour of the $i$-th customer is $D_i$ and this customer is willing to pay $F_i$ units of money for a drink with this flavour, or $B_i$ units of money for a drink with any other flavuor. Whenever a customer wants to buy a drink:
- if it is possible to sell this customer a drink with their favourite flavour, Chef must sell them a drink with this flavour
- otherwise, Chef must sell this customer a drink, but he may choose its flavour
Chef wants to make the maximum possible profit. He is asking you to help him decide the flavours of the drinks he should sell to the customers in order to maximise the profit.
-----Input-----
- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
- The first line of each test case contains two space-separated integers $N$ and $M$.
- The second line contains $M$ space-separated integers $C_1, C_2, \ldots, C_M$.
- $N$ lines follow. For each valid $i$, the $i$-th of these lines contains three space-separated integers $D_i$, $F_i$ and $B_i$.
-----Output-----
For each test case, print two lines:
- The first of these lines should contain a single integer — the maximum profit.
- The second line should contain $N$ space-separated integers denoting the flavours of the drinks Chef should sell, in this order.
If there are multiple solutions, you may find any one.
-----Constraints-----
- $1 \le T \le 1,000$
- $2 \le N, M \le 10^5$
- $1 \le D_i \le M$ for each valid $i$
- $1 \le C_i \le N$ for each valid $i$
- $1 \le B_i < F_i \le 10^9$ for each valid $i$
- $C_1+C_2+\ldots+C_M \ge N$
- the sum of $N$ over all test cases does not exceed $10^6$
- the sum of $M$ over all test cases does not exceed $10^6$
-----Example Input-----
1
5 3
1 2 3
2 6 3
2 10 7
2 50 3
1 10 5
1 7 4
-----Example Output-----
33
2 2 3 1 3
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,m=list(map(int,input().split()))
l=[0]+list(map(int,input().split()))
s=0
c=1
m1=[]
for i in range(n):
d,f,b=list(map(int,input().split()))
if(l[d]>0):
m1.append(d)
s+=f
l[d]-=1
else:
m1.append(0)
s+=b
for i in range(n):
if(m1[i]==0):
for j in range(c,m+1):
if(l[j]>0):
m1[i]=j
l[j]-=1
c=j
break
print(s)
print(*m1)
``` | {
"language": "python",
"test_cases": [
{
"input": "1\n5 3\n1 2 3\n2 6 3\n2 10 7\n2 50 3\n1 10 5\n1 7 4\n",
"output": "33\n2 2 3 1 3\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/SLUSH"
} | vfc_4546 |
apps | verifiable_code | 1427 | Solve the following coding problem using the programming language python:
Today, puppy Tuzik is going to a new dog cinema. He has already left his home and just realised that he forgot his dog-collar! This is a real problem because the city is filled with catchers looking for stray dogs.
A city where Tuzik lives in can be considered as an infinite grid, where each cell has exactly four neighbouring cells: those sharing a common side with the cell. Such a property of the city leads to the fact, that the distance between cells (xA, yA) and (xB, yB) equals |xA - xB| + |yA - yB|.
Initially, the puppy started at the cell with coordinates (0, 0). There are N dog-catchers located at the cells with the coordinates (xi, yi), where 1 ≤ i ≤ N. Tuzik's path can be described as a string S of M characters, each of which belongs to the set {'D', 'U', 'L', 'R'} (corresponding to it moving down, up, left, and right, respectively). To estimate his level of safety, Tuzik wants to know the sum of the distances from each cell on his path to all the dog-catchers. You don't need to output this sum for the staring cell of the path (i.e. the cell with the coordinates (0, 0)).
-----Input-----
The first line of the input contains two integers N and M.
The following N lines contain two integers xi and yi each, describing coordinates of the dog-catchers.
The last line of the input contains string S of M characters on the set {'D', 'U', 'L', 'R'}.
- 'D' - decrease y by 1
- 'U' - increase y by 1
- 'L' - decrease x by 1
- 'R' - increase x by 1
-----Output-----
Output M lines: for each cell of the path (except the starting cell), output the required sum of the distances.
-----Constraints-----
- 1 ≤ N ≤ 3 ✕ 105
- 1 ≤ M ≤ 3 ✕ 105
- -106 ≤ xi, yi ≤ 106
-----Example-----
Input:
2 3
1 2
0 1
RDL
Output:
4
6
6
-----Explanation-----
Initially Tuzik stays at cell (0, 0). Let's consider his path:
- Move 'R' to the cell (1, 0). Distance to the catcher (1, 2) equals 2, distance to the catcher (0, 1) equals 2, so the total distance equals 4
- Move 'D' to the cell (1, -1). Distance to the catcher (1, 2) equals 3, distance to the catcher (0, 1) equals 3, so the total distance equals 6
- Move 'L' to the cell (0, -1). Distance to the catcher (1, 2) equals 4, distance to the catcher (0, 1) equals 2, so the total distance equals 6
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
# cook your dish here
from sys import stdin,stdout
a,b=list(map(int,stdin.readline().split()))
left=[]
top=[]
for i in range(a):
c,d=list(map(int,stdin.readline().split()))
left.append(c)
top.append(d)
left.sort()
top.sort()
from bisect import bisect_right as br
from bisect import bisect_left as bl
row=0
col=0
total=0
cons_x=0
cons_y=0
for i in range(len(left)):
cons_x+=(abs(left[i]))
cons_y+=(abs(top[i]))
total=cons_x+cons_y
cc=stdin.readline().rstrip()
for i in cc:
if i=="R":
kk=br(left,col)
cons_x=(cons_x+kk-(a-kk))
col+=1
if i=="L":
kk=bl(left,col)
cons_x=(cons_x+(a-kk)-kk)
col-=1
if i=="U":
kk=br(top,row)
cons_y=(cons_y+kk-(a-kk))
row+=1
if i=="D":
kk=bl(top,row)
cons_y=(cons_y+(a-kk)-kk)
row-=1
stdout.write(str(cons_x+cons_y))
stdout.write("\n")
``` | {
"language": "python",
"test_cases": [
{
"input": "2 3\n1 2\n0 1\nRDL\n",
"output": "4\n6\n6\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/PPCTS"
} | vfc_4550 |
apps | verifiable_code | 1428 | Solve the following coding problem using the programming language python:
Pied Piper is a startup company trying to build a new Internet called Pipernet. Currently, they have $A$ users and they gain $X$ users everyday. There is also another company called Hooli, which has currently $B$ users and gains $Y$ users everyday.
Whichever company reaches $Z$ users first takes over Pipernet. In case both companies reach $Z$ users on the same day, Hooli takes over.
Hooli is a very evil company (like E-Corp in Mr. Robot or Innovative Online Industries in Ready Player One). Therefore, many people are trying to help Pied Piper gain some users.
Pied Piper has $N$ supporters with contribution values $C_1, C_2, \ldots, C_N$. For each valid $i$, when the $i$-th supporter contributes, Pied Piper gains $C_i$ users instantly. After contributing, the contribution value of the supporter is halved, i.e. $C_i$ changes to $\left\lfloor C_i / 2 \right\rfloor$. Each supporter may contribute any number of times, including zero. Supporters may contribute at any time until one of the companies takes over Pipernet, even during the current day.
Find the minimum number of times supporters must contribute (the minimum total number of contributions) so that Pied Piper gains control of Pipernet.
-----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 six space-separated integers $N$, $A$, $B$, $X$, $Y$ and $Z$.
- The second line contains $N$ space-separated integers $C_1, C_2, \ldots, C_N$ — the initial contribution values.
-----Output-----
For each test case, if Hooli will always gain control of Pipernet, print a single line containing the string "RIP" (without quotes). Otherwise, print a single line containing one integer — the minimum number of times supporters must contribute.
-----Constraints-----
- $1 \le T \le 10$
- $1 \le N \le 10^5$
- $1 \le A, B, X, Y, Z \le 10^9$
- $A, B < Z$
- $0 \le C_i \le 10^9$ for each valid $i$
-----Example Input-----
3
3 10 15 5 10 100
12 15 18
3 10 15 5 10 100
5 5 10
4 40 80 30 30 100
100 100 100 100
-----Example Output-----
4
RIP
1
-----Explanation-----
Example case 1: After $8$ days, Pied Piper will have $50$ users and Hooli will have $95$ users. Then, if each supporter contributes once, Pied Piper will also have $95$ users. After that, they still need $5$ more users, so supporter $3$ can contribute again, with $18/2 = 9$ more users. So the answer will be $4$.
Example case 2: There is no way to beat Hooli.
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 heapq as hq
from math import floor
for _ in range(int(input())):
n,a,b,x,y,z=map(int,input().split())
arr=[-int(i) for i in input().split()]
days=((z-b-1)//y)
ans=0
hq.heapify(arr)
curr=a+days*x
while curr<z :
u=hq.heappop(arr)
u=-u
if u==0 :
break
else:
curr+=u
ans+=1
hq.heappush(arr,-(u//2))
if curr>=z:
print(ans)
else:
print("RIP")
``` | {
"language": "python",
"test_cases": [
{
"input": "3\n3 10 15 5 10 100\n12 15 18\n3 10 15 5 10 100\n5 5 10\n4 40 80 30 30 100\n100 100 100 100\n",
"output": "4\nRIP\n1\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/PEWDSVTS"
} | vfc_4554 |
apps | verifiable_code | 1430 | Solve the following coding problem using the programming language python:
Chef wants you to distribute candies among $N$ kids who are sitting in a circle. However, he wants to make some kids jealous of others. Thus, he wants you to distribute candies in such a way that there is a difference of at least $K$ candies between two adjacent kids.
Given the value of $N$ and $K$, you need to find the minimum number of candies you need to satisfy the given conditions, such that, each kid gets at least one candy.
-----Input:-----
- First line will contain $T$, the number of testcases. Then the testcases follow.
- The only line of each testcase contains two space-separated integers $N$ and $K$.
-----Output:-----
For each test case, print a single line containing one integer ― the number of candies you need.
-----Constraints-----
- $1 \leq T \leq 10^6$
- $2 \leq N \leq 10^3$
- $0 \leq K \leq 10^4$
-----Sample Input:-----
1
2 1
-----Sample Output:-----
3
-----EXPLANATION:-----
The minimum number of candies required is $3$. One kid needs to have $1$ candy and the other needs to have $2$ candy to have a difference of $1$ candy between them.
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())):
n,k = [int(v) for v in input().split()]
ans = (n//2)*(k+2)
if n%2 == 0:
ans = ans
else:
ans += 1 + 2*k
print(ans)
``` | {
"language": "python",
"test_cases": [
{
"input": "1\n2 1\n",
"output": "3\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/AGPR2020/problems/ALPR2000"
} | vfc_4562 |
apps | verifiable_code | 1431 | Solve the following coding problem using the programming language python:
After the hundred years of war started by the Fire Nation, its time for the Water Tribes to bring it to an end. Avatar asked Sokka to go to the Southern WarZone from The Northern WarZone and gave him some money in a bag for his journey. Sokka has the World Map to guide him during his journey . The World Map is described as a $N$x$N$ grid where the Northern WarZone is denoted by $(0,0)$ and the Southern WarZone is denoted by $(N-1,N-1)$. Each location on the world map is denoted in a similar way by two integers r and c. For each location having:
- $r = c$ denotes neutral land ( $(0,0)$ and $(N-1,N-1)$ also come under this category)
- $r < c$ denotes the land under the rule of Water Tribes
- $r > c$ denotes the land under the rule of Fire Kingdom
Being wise Sokka travels only from one location to any other valid location (by valid location we mean a location which exists on the world map grid i.e. for that location $0 \leq r < N$ and $0 \leq c < N$ ) just to the right $(r,c+1)$ or below $(r+1,c)$ the current location randomly. Due to the times of war , Sokka has to pay one coin each time he transitions from one nation to another. Here a transition is counted when Sokka is in Water Tribe land and moves to Fire Nation Land crossing the neutral land or vice versa .The first move is obviously never counted as a transition. Moreover , the coin is to be payed exactly once for one such transition (eg. if he makes this transition k times he has to pay k coins).
The initial number of coins Sokka has is $2*N$. The probability that the coins he has when he reaches his destination is lesser than the number of coins he started his journey with can be expressed as a fraction $P/Q$, where P and Q are integers $(P \geq 0, Q > 0)$ and Q is co-prime with $(10^9)+7$. You should compute $P/Q$ modulo $(10^9)+7$ for $T$ values of $N$.
-----Input:-----
- First line will contain $T$, number of testcases. Then the testcases follow.
- Each testcase contains of a single line of input, one integer $N$, the size of the world map grid.
-----Output:-----
For each testcase, output in a single line , the Probability modulo (10^9)+7.
-----Constraints-----
- $1 \leq T \leq 100000$
- $2 \leq N \leq 10^9$
-----Sample Input:-----
2
5
2
-----Sample Output:-----
200000002
0
-----EXPLANATION:-----
For N=2, there is no possible path in which Sokka has to spend money, so the final number of coins in the bag is not lesser than the initial amount.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
m=1000000007
def gcd(a, b):
if (a == 0):
return b
return gcd(b % a, a)
def modexp(x, n):
if (n == 0) :
return 1
elif (n % 2 == 0) :
return modexp((x * x) % m, n // 2)
else :
return (x * modexp((x * x) % m,
(n - 1) / 2) % m)
def getFractionModulo(a, b):
c = gcd(a, b)
a = a // c
b = b // c
d = modexp(b, m - 2)
ans = ((a % m) * (d % m)) % m
return ans
t=int(input())
for i in range(t):
n=int(input())
n=n-1
print(getFractionModulo(n-1,n+1))
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n5\n2\n",
"output": "200000002\n0\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/COW42020/problems/COW3F"
} | vfc_4566 |
apps | verifiable_code | 1433 | Solve the following coding problem using the programming language python:
The Little Elephant loves lucky strings. Everybody knows that the lucky string is a string of digits that contains only the lucky digits 4 and 7. For example, strings "47", "744", "4" are lucky while "5", "17", "467" are not.
The Little Elephant has the strings A and B of digits. These strings are of equal lengths, that is |A| = |B|. He wants to get some lucky string from them. For this he performs the following operations. At first he arbitrary reorders digits of A. Then he arbitrary reorders digits of B. After that he creates the string C such that its i-th digit is the maximum between the i-th digit of A and the i-th digit of B. In other words, C[i] = max{A[i], B[i]} for i from 1 to |A|. After that he removes from C all non-lucky digits saving the order of the remaining (lucky) digits. So C now becomes a lucky string. For example, if after reordering A = "754" and B = "873", then C is at first "874" and then it becomes "74".
The Little Elephant wants the resulting string to be as lucky as possible. The formal definition of this is that the resulting string should be the lexicographically greatest possible string among all the strings that can be obtained from the given strings A and B by the described process.
Notes
- |A| denotes the length of the string A.
- A[i] denotes the i-th digit of the string A. Here we numerate the digits starting from 1. So 1 ≤ i ≤ |A|.
- The string A is called lexicographically greater than the string B if either there exists some index i such that A[i] > B[i] and for each j < i we have A[j] = B[j], or B is a proper prefix of A, that is, |A| > |B| and first |B| digits of A coincide with the corresponding digits of B.
-----Input-----
The first line of the input contains a single integer T, the number of test cases. T test cases follow. Each test case consists of two lines. The first line contains the string A. The second line contains the string B.
-----Output-----
For each test case output a single line containing the answer for the corresponding test case. Note, that the answer can be an empty string. In this case you should print an empty line for the corresponding test case.
-----Constraints-----
1 ≤ T ≤ 10000
1 ≤ |A| ≤ 20000
|A| = |B|
Each character of A and B is a digit.
Sum of |A| across all the tests in the input does not exceed 200000.
-----Example-----
Input:
4
4
7
435
479
7
8
1675475
9756417
Output:
7
74
777744
-----Explanation-----
Case 1. In this case the only possible string C we can get is "7" and it is the lucky string.
Case 2. If we reorder A and B as A = "543" and B = "749" the string C will be at first "749" and then becomes "74". It can be shown that this is the lexicographically greatest string for the given A and B.
Case 3. In this case the only possible string C we can get is "8" and it becomes and empty string after removing of non-lucky digits.
Case 4. If we reorder A and B as A = "7765541" and B = "5697714" the string C will be at first "7797744" and then becomes "777744". Note that we can construct any lexicographically greater string for the given A and B since we have only four "sevens" and two "fours" among digits of both strings A and B as well the constructed string "777744".
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):
a = input()
b = input()
agts=bgts=afour=bfour=aseven=bseven=altf=bltf=afts=bfts=0;
for j in a:
if j >= '7':
if j > '7':
agts += 1
else:
aseven += 1
elif j >= '4':
if j > '4':
afts += 1
else:
afour += 1
else:
altf += 1
for j in b:
if j >= '7':
if j > '7':
bgts += 1
else:
bseven += 1
elif j >= '4':
if j > '4':
bfts += 1
else:
bfour += 1
else:
bltf += 1
nseven = 0
nfour = 0
if aseven > bfts:
aseven -= bfts;
nseven += bfts;
bfts = 0;
else:
bfts -= aseven;
nseven += aseven;
aseven = 0;
if bseven > afts:
bseven -= afts;
nseven += afts;
afts = 0;
else:
afts -= bseven;
nseven += bseven;
bseven = 0;
if aseven > bltf:
aseven -= bltf;
nseven += bltf;
bltf = 0;
else:
bltf -= aseven;
nseven += aseven;
aseven = 0;
if bseven > altf:
bseven -= altf;
nseven += altf;
altf = 0;
else:
altf -= bseven;
nseven += bseven;
bseven = 0;
if aseven > bfour:
aseven -= bfour;
nseven += bfour;
bfour = 0;
else:
bfour -= aseven;
nseven += aseven;
aseven = 0;
if bseven > afour:
bseven -= afour;
nseven += afour;
afour = 0;
else:
afour -= bseven;
nseven += bseven;
bseven = 0;
nseven += min(aseven,bseven)
if afour > bltf:
afour -= bltf;
nfour += bltf;
bltf = 0
else:
bltf -= afour;
nfour += afour;
afour = 0;
if bfour > altf:
bfour -= altf;
nfour += altf;
altf = 0
else:
altf -= bfour;
nfour += bfour;
bfour = 0;
nfour += min(afour,bfour)
print('7'*nseven + '4'*nfour)
``` | {
"language": "python",
"test_cases": [
{
"input": "4\n4\n7\n435\n479\n7\n8\n1675475\n9756417\n\n\n",
"output": "7\n74\n\n777744\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/OCT12/problems/LUCKY10"
} | vfc_4574 |
apps | verifiable_code | 1434 | Solve the following coding problem using the programming language python:
There's a tree and every one of its nodes has a cost associated with it. Some of these nodes are labelled special nodes. You are supposed to answer a few queries on this tree. In each query, a source and destination node (SNODE$SNODE$ and DNODE$DNODE$) is given along with a value W$W$. For a walk between SNODE$SNODE$ and DNODE$DNODE$ to be valid you have to choose a special node and call it the pivot P$P$. Now the path will be SNODE$SNODE$ ->P$ P$ -> DNODE$DNODE$. For any valid path, there is a path value (PV$PV$) attached to it. It is defined as follows:
Select a subset of nodes(can be empty) in the path from SNODE$SNODE$ to P$P$ (both inclusive) such that sum of their costs (CTOT1$CTOT_{1}$) doesn't exceed W$W$.
Select a subset of nodes(can be empty) in the path from P$P$ to DNODE$DNODE$ (both inclusive) such that sum of their costs (CTOT2$CTOT_{2}$) doesn't exceed W$W$.
Now define PV=CTOT1+CTOT2$PV = CTOT_{1} + CTOT_{2}$ such that the absolute difference x=|CTOT1−CTOT2|$x = |CTOT_{1} - CTOT_{2}|$ is as low as possible. If there are multiple pairs of subsets that give the same minimum absolute difference, the pair of subsets which maximize PV$PV$ should be chosen.
For each query, output the path value PV$PV$ minimizing x$x$ as defined above.
Note that the sum of costs of an empty subset is zero.
-----Input-----
- First line contains three integers N$N$ - number of vertices in the tree, NSP$NSP$ - number of special nodes in the tree and Q$Q$ - number of queries to answer.
- Second line contains N−1$N-1$ integers. If the i$i$th integer is Vi$V_i$ then there is an undirected edge between i+1$i + 1$ and Vi$V_i$ (i$i$ starts from 1$1$ and goes till N−1$N-1$).
- Third line contains N$N$ integers, the i$i$th integer represents cost of the i$i$th vertex.
- Fourth line contains NSP$NSP$ integers - these represent which nodes are the special nodes.
- Following Q$Q$ lines contains three integers each - SNODE$SNODE$, DNODE$DNODE$ and W$W$ for each query.
-----Output-----
For each query output a single line containing a single integer - the path value PV$PV$ between SNODE$SNODE$ and DNODE$DNODE$.
-----Constraints:-----
- 1≤$1 \leq $ Number of nodes ≤1000$ \leq 1000 $
- 0≤W≤1000$ 0 \leq W \leq 1000 $
- 1≤$ 1 \leq $ Number of special nodes ≤10$ \leq 10 $
- 0≤$ 0 \leq $ Cost of each node ≤1000$ \leq 1000 $
- 1≤$ 1 \leq $ Number of queries ≤1000$ \leq 1000 $
-----Sample Input-----
7 1 5
1 1 2 2 3 3
3 5 4 2 7 9 1
1
2 3 100
1 1 100
2 1 100
4 5 100
4 7 100
-----Sample Output:-----
6
6
6
20
16
-----Explanation:-----
Consider query 4$4$. The only path is 4−>2−>1−>2−>5$4->2->1->2->5$. The two sets defined for this path are {3,2,5${3,2,5}$} and {3,5,7${3,5,7}$}. Pick subsets {3,2,5${3,2,5}$} and {3,7${3,7}$} from each set which minimizes PV$PV$. Note that node 2$2$ can repeat as it is in different paths (both to and from the pivot).
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
# cook your dish here
import numpy as np
n, s, q = [int(j) for j in input().split()]
edges = [int(j)-1 for j in input().split()]
costs = [int(j) for j in input().split()]
special = [int(j)-1 for j in input().split()]
queries = [[0] * 3 for _ in range(q)]
for i in range(q):
queries[i] = [int(j)-1 for j in input().split()]
edge_set = [[] for _ in range(n)]
for i in range(n-1):
edge_set[i+1].append(edges[i])
edge_set[edges[i]].append(i+1)
stored = np.zeros((s,n,1001),dtype=bool)
visited = [[] for _ in range(s)]
for i in range(s):
s_vertex = special[i]
s_cost = costs[s_vertex]
s_visited = visited[i]
s_visited.append(s_vertex)
s_stored = stored[i]
s_stored[s_vertex][0] = True
s_stored[s_vertex][s_cost] = True
for edge in edge_set[s_vertex]:
s_visited.append(edge)
s_stored[edge] = np.array(s_stored[s_vertex])
for j in range(1,n):
vertex = s_visited[j]
cost = costs[vertex]
s_stored[vertex][cost:1001] = np.logical_or(s_stored[vertex][0:1001-cost],s_stored[vertex][cost:1001])
for edge in edge_set[vertex]:
if edge not in s_visited:
s_visited.append(edge)
s_stored[edge] = np.array(s_stored[vertex])
for i in range(q):
first, second, max_cost = queries[i]
bool_array = np.zeros(max_cost+2,dtype=bool)
for j in range(s):
bool_array = np.logical_or(bool_array,np.logical_and(stored[j][first][:max_cost+2],stored[j][second][:max_cost+2]))
for j in range(max_cost+1,-1,-1):
if bool_array[j]:
print(2 * j)
break
``` | {
"language": "python",
"test_cases": [
{
"input": "7 1 5\n1 1 2 2 3 3\n3 5 4 2 7 9 1\n1\n2 3 100\n1 1 100\n2 1 100\n4 5 100\n4 7 100\n",
"output": "6\n6\n6\n20\n16\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/DEMTREE"
} | vfc_4578 |
apps | verifiable_code | 1435 | Solve the following coding problem using the programming language python:
Indraneel's student has given him data from two sets of experiments that the student has performed. Indraneel wants to establish a correlation between the two sets of data. Each data set is a sequence of $N$ numbers. The two data sets do not match number for number, but Indraneel believes that this is because data has been shifted due to inexact tuning of the equipment.
For example, consider the following two sequences:
$ $
3 8 4 23 9 11 28
2 3 22 26 8 16 12
$ $
Indraneel observes that if we consider the subsequences $3,4,23,9$ and $2,3,22,8$ and examine their successive differences we get $1,19,-14$. He considers these two subsequences to be "identical". He would like to find the longest such pair of subsequences so that the successive differences are identical. Your task is to help him do this.
-----Input:-----
The first line of the input will contain a single integer $N$ indicating the number of data points in each of Indraneel's student's data sets. This is followed by two lines, each containing $N$ integers.
-----Output:-----
The output consists of three lines. The first line of output contains a single integer indicating the length of the longest pair of subsequences (one from each sequence) that has identical successive differences. This is followed by two lines each containing the corresponding subsequences. If there is more than one answer, it suffices to print one.
-----Constraints:-----
- $1 \leq N \leq 150$.
- $0 \leq$ Each data point $\leq 1000$
-----Sample Input-----
7
3 8 4 23 9 11 28
2 3 22 26 8 16 12
-----Sample Output-----
4
3 4 23 9
2 3 22 8
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
import copy
n=int(input())
a=[int(x) for x in input().split()]
b=[int(x) for x in input().split()]
c=[]
d=[]
lcs=[]
def lcsfn(a,c,corda,cordb):
for i in range(n+1):
d.append([0]*(n+1))
lcs.append([0]*(n+1))
for i in range(1,n+1):
for j in range(1,n+1):
if a[i-1]==c[j-1]:
lcs[i][j]=lcs[i-1][j-1]+1
d[i][j]='d'
elif lcs[i-1][j]>lcs[i][j-1]:
lcs[i][j]=lcs[i-1][j]
d[i][j]='u'
else:
lcs[i][j]=lcs[i][j-1]
d[i][j]='l'
i=n
j=n
cost=0
while i>=1 and j>=1:
if d[i][j]=='d':
corda.append(a[i-1])
cordb.append(b[j-1])
i-=1
j-=1
cost+=1
elif d[i][j]=='l':
j-=1
elif d[i][j]=='u':
i-=1
return cost
ma=-10**9
p1=[]
p2=[]
for i in range(-1000,1001):
c=[]
corda=[]
cordb=[]
for j in range(n):
c.append(b[j]+i)
p=lcsfn(a,c,corda,cordb)
if ma<p:
ma=p
p1=copy.deepcopy(corda)
p1=p1[::-1]
p2=copy.deepcopy(cordb)
p2=p2[::-1]
print(ma)
print(*p1)
print(*p2)
``` | {
"language": "python",
"test_cases": [
{
"input": "7\n3 8 4 23 9 11 28\n2 3 22 26 8 16 12\n",
"output": "4\n3 4 23 9\n2 3 22 8\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/IARCSJUD/problems/EXPT"
} | vfc_4582 |
apps | verifiable_code | 1436 | Solve the following coding problem using the programming language python:
Harrenhal is the largest castle in the Seven Kingdoms and is the seat of House Whent in the Riverlands, on the north shore of the Gods Eye lake. Since the War of Conquest, however, it has become a dark and ruinous place.
(c) A Wiki of Ice and Fire
Now Harrenhal is too dangerous since it's a nice place for bandits to hide, or even for rebels to start planning overthrowing of the king. So, the current Lord of the Seven Kingdoms has decided, that it's time to completely ruin the castle. For that puposes, he's planning to send some military troops.
In this problem we assume, that Harrenhal can be described as a string H, which consists only of symbols 'a' and 'b'. Harrenhal is completely ruined if and only if the length of H is equal to zero.
So, how to make H empty? Send a military troop! When a military troop of the king reach the castle, they delete some palindromic subsequence S of H. For example, let H = 'abbabaab'. Then the current military troop can choose S = 'ababa'(Let's make symbols of S bold in H: 'abbabaab'). After deleting S, H will be equal to 'bab'. Military troops are free to choose any possible palindromic subsequence of H.
Your task is pretty simple: determine the minimal number of military troops, that the Lord of the Seven Kingdoms has to send in order to ruin Harrenhal.
-----Note-----
Maybe, some of you aren't familiar with definitions from the statement. Here're some articles that could help you to understand the problem correctly:
- Subsequence: http://en.wikipedia.org/wiki/Subsequence
- Palindrome: http://en.wikipedia.org/wiki/Palindrome
-----Input-----
The first line of the input contains an integer T, denoting the number of test cases.
The next T lines contain a string H each, denoting the string, that describes the current state of Harrenhal for the corresponding test cases.
It's guaranteed, that each H consists only of symbols 'a' and 'b'.
-----Output-----
The output should contain exactly T lines. i'th line of the output should contain the only integer: the minimal number of military troops, that the Lord of the Seven Kingdoms has to send in order to ruin Harrenhal for the corresponding test cases.
-----Constraints-----
- 1 ≤ |H| ≤ 100000, for each H.
- Subtask 1(30 points): each H in the input is a palindrome, 1 ≤ T ≤ 6;
- Subtask 2(70 points): 1 ≤ T ≤ 9.
-----Example-----
Input:
1
abbabaab
Output:
2
-----Explanation-----
There're multiple ways to ruin Harrenhal in the example test. Let's consider one of them.
The first troop can delete S = 'ababa'('abbabaab'). After that, H = 'bab'.
The second troop can delete S = 'bab'('bab'). After that, H is empty and that's it.
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())):
g=input()
h=g[::-1]
if h==g :
print(1)
else:
print(2)
``` | {
"language": "python",
"test_cases": [
{
"input": "1\nabbabaab\n\n\n",
"output": "2\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/HHAL"
} | vfc_4586 |
apps | verifiable_code | 1437 | 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()
``` | {
"language": "python",
"test_cases": [
{
"input": "3\n2\n2 3\n2\n4 2\n3\n12 3 2\n",
"output": "6\n8\n-1\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/BRBG2020/problems/FTNUM"
} | vfc_4590 |
apps | verifiable_code | 1438 | Solve the following coding problem using the programming language python:
Mandarin chinese
, Russian and Vietnamese as well.
Let's denote $S(x)$ by the sum of prime numbers that divides $x$.
You are given an array $a_1, a_2, \ldots, a_n$ of $n$ numbers, find the number of pairs $i, j$ such that $i \neq j$, $a_i$ divides $a_j$ and $S(a_i)$ divides $S(a_j)$.
-----Input:-----
- First line will contain $T$, number of testcases. Then the testcases follow.
- First line of each testcase contains one integer $n$ — number of elements of the array.
- Second line of each testcase contains $n$ space-separated integers $a_1, a_2, \ldots, a_n$.
-----Output:-----
For each testcase, output in a single line number of pairs that each of it satisfies given conditions.
-----Constraints-----
- $1 \leq T \leq 100$
- $2 \leq n, a_i \leq 10^6$
- the sum of $n$ for all test cases does not exceed $10^6$
-----Subtasks-----
Subtask #2 (20 points): $2 \leq n \leq 100$, $2 \leq a_i \leq 10^4$
Subtask #2 (80 points): original contsraints
-----Sample Input:-----
1
5
2 30 2 4 3
-----Sample Output:-----
6
-----EXPLANATION:-----
$S(2) = 2, S(30) = 2 + 3 + 5 = 10, S(4) = 2, S(3) = 3$. So using this information, the pairs of indicies are $(1,2)$, $(1, 3)$, $(1, 4)$, $(3, 1)$, $(3, 2)$, $(3, 4)$.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
# cook your dish here
def prime_factors(n):
i = 2
factors =set()
while i * i <= n:
if n % i:
i += 1
else:
n //= i
factors.add(i)
if n > 1:
factors.add(n)
return factors
for _ in range(int(input())):
n=int(input())
a=list(map(int,input().split()))
ans=0
s=[]
for i in range(n):
s.append(sum(prime_factors(a[i])))
for i in range(n):
for j in range(n):
if i!=j and a[j]%a[i]==0 and s[j]%s[i]==0:
ans=ans+1
print(ans)
``` | {
"language": "python",
"test_cases": [
{
"input": "1\n5\n2 30 2 4 3\n",
"output": "6\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/PRMDIV"
} | vfc_4594 |
apps | verifiable_code | 1439 | Solve the following coding problem using the programming language python:
Chef has arrived in Dagobah to meet with Yoda to study cooking. Yoda is a very busy cook and he doesn't want to spend time with losers. So he challenges the Chef to a series of games, and agrees to teach the Chef if Chef can win at least P of the games. The total number of games is K. The games will be played on a chessboard of size N*M. That is, it has N rows, each of which has M squares. At the beginning of the game, a coin is on square (1, 1), which corresponds to the top-left corner, and every other square is empty. At every step, Yoda and Chef have to move the coin on the chessboard. The player who cannot make a move loses. Chef makes the first move. They can't move the coin to a square where it had been placed sometime before in the game, and they can't move outside chessboard.
In this game, there are two different sets of rules according to which the game can be played:
-from (x, y) player can move coin to (x+1, y), (x-1, y), (x, y+1), (x, y-1) in his turn, if they are valid squares.
-from (x, y) player can move coin to (x+1, y+1), (x-1, y-1), (x-1, y+1), (x+1, y-1) in his turn, if they are valid squares.
Before every game, the Power of the kitchen chooses one among the two sets of rules with equal probability of 0.5, and the game will be played according to those rules. Chef and Yoda are very wise, therefore they play optimally. You have to calculate the probability that Yoda will teach Chef.
-----Input-----
Input begins with an integer T, the number of test cases
Each test case begins with 4 integers N, M, P, K.
-----Output-----
For each test case, output a line containing the answer for task. The output must have an absolute error at most 0.000001 (10-6).
-----Constraints and Subtasks-----
- 1 ≤ T ≤ 50
- 1 ≤ K
Subtask 1 : 10 points
- 2 ≤ N, M ≤ 5
- 0 ≤ P ≤ K ≤ 5
Subtusk 2 : 10 points
- 2 ≤ N, M ≤ 10
- 0 ≤ P ≤ K ≤ 10^3
Subtusk 3 : 20 points
- 2 ≤ N, M ≤ 100
- 0 ≤ P ≤ K ≤ 10^3
Subtusk 4 : 60 points
- 2 ≤ N, M ≤ 100
- 0 ≤ P ≤ K ≤ 10^6
-----Example-----
Input:
2
2 3 2 3
2 2 5 5
Output:
0.500000
1.000000
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
import math
dp = []
dp.append(0)
for i in range(1,1000005):
dp.append(math.log(i) + dp[i-1])
t = int(input())
for i in range(t):
n,m,p,k = input().split()
n = int(n)
m = int(m)
p = int(p)
k = int(k)
if p==0 or (n%2==0 and m%2==0):
ans = 1.0
print(ans)
elif n%2==1 and m%2==1:
ans=0.0
print(ans*100)
else:
P = 0
kln2 = k*math.log(2)
for i in range(p, k+1):
lnPi = dp[k] - dp[i] - dp[k-i] - kln2
Pi = pow(math.e, lnPi)
P += Pi
print(P)
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n2 3 2 3\n2 2 5 5\n",
"output": "0.500000\n1.000000\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/CHEFYODA"
} | vfc_4598 |
apps | verifiable_code | 1440 | Solve the following coding problem using the programming language python:
You are given an array $A$ of $N$ positive and pairwise distinct integers.
You can permute the elements in any way you want.
The cost of an ordering $(A_1, A_2, \ldots, A_N)$ is defined as $ (((A_1 \bmod A_2) \bmod A_3)......) \bmod A_N$ where $X \bmod Y$ means the remainder when $X$ is divided by $Y$.
You need to find the maximum cost which can be attained through any possible ordering of the elements.
-----Input:-----
- The first line contains $T$ denoting the number of test cases.
- The first line of each testcase contains a single integer $N$.
- The second line of each testcase contains $N$ space-separated integers, the elements of $A$.
-----Output:-----
- For each testcase, output the maximum possible cost in a new line.
-----Constraints-----
- $1 \leq T \leq 5*10^5$
- $2 \leq N \leq 5*10^5$
- $1 \leq A_i \leq 10^9$
- Sum of $N$ over all testcases is less than or equal to $10^6$
- All elements in a single testcase are distinct.
-----Subtasks-----
- 100 points : Original constraints.
-----Sample Input:-----
1
2
7 12
-----Sample Output:-----
7
-----Explanation:-----
The two possible ways to order the elements are [7, 12] and [12, 7]. In the first case, the cost is $7 \bmod 12 = 7$ and in the second case the cost is $12 \bmod 7 = 5$. Clearly the answer is 7.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
# cook your dish here
t=int(input())
for i in range(t):
n=int(input())
a=list(map(int,input().split()))
print(min(a))
``` | {
"language": "python",
"test_cases": [
{
"input": "1\n2\n7 12\n",
"output": "7\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/EXUNA"
} | vfc_4602 |
apps | verifiable_code | 1441 | Solve the following coding problem using the programming language python:
Chef is again playing a game with his best friend Garry. As usual, the rules of this game are extremely strange and uncommon.
First, they are given a stack of $N$ discs. Each disc has a distinct, non-negative integer written on it. The players exchange turns to make a move. Before the start of the game, they both agree upon a set of positive integers $S$ of size $K$. It is guaranteed that S contains the integer $1$. In a move, a player can select any value $x$ from $S$ and pop exactly $x$ elements from the top of the stack. The game ends when there are no discs remaining. Chef goes first.
Scoring: For every disc a player pops, his score increases by $2^p$ where $p$ is the integer written on the disc. For example, if a player pops the discs, with integers $p_1, p_2, p_3, \dots, p_m$ written on it, during the entire course of the game, then his total score will be $2^{p_1} + 2^{p_2} + 2^{p_3} + \dots + 2^{p_m}$.
The player with higher score wins the game. Determine the winner if both the players play optimally, or if the game ends in a draw.
-----Input:-----
- First line contains $T$, the number of testcases. Then the testcases follow.
- The first line of each test case contains two space separated integers $N$ and $K$, denoting the size of the stack and the set S respectively.
- Next line contains $N$ space separated integers $A_i$ where $A_1$ is the topmost element, denoting the initial arrangement of the stack.
- The last line of each test case contains $K$ space separated integers each denoting $x_i$.
-----Output:-----
For each testcase, output "Chef" (without quotes) if Chef wins, "Garry" (without quotes) if Garry wins, otherwise "Draw" (without quotes) in a separate line.
-----Constraints-----
- $1 \leq T \leq 1000$
- $1 \leq N \leq 10^5$
- $1 \leq K \leq \min(100, N)$
- $0 \leq A_i \leq 10^9$
- $1 \leq x_i \leq N$
- $x_i \neq x_j$ for all $i \neq j$
- $A_i \neq A_j$ for all $i \neq j$
- Set $S$ contains integer $1$.
- Sum of $N$ over all test cases does not exceed $10^5$.
-----Sample Input:-----
1
3 2
5 7 1
1 2
-----Sample Output:-----
Chef
-----Explanation:-----
Chef can select 2 from the set and draw the top two discs (with integers 5 and 7 written on it) from the stack. Garry cannot select 2 from the set as there is only 1 disc left in the stack. However, he can select 1 from the set and pop the last disc.
So, Chef's score = $2^5$ + $2^7$ = $160$
Garry's score = $2^1$ = $2$
Chef wins.
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())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
a = [-1] + a[::-1]
mx = a.index(max(a))
dp = [0] * (n + 1)
for i in range(1, n + 1):
for x in b:
if i - x < 0: continue
if i - x < mx <= i:
dp[i] = 1
else:
dp[i] |= not dp[i - x]
print('Chef' if dp[-1] else 'Garry')
``` | {
"language": "python",
"test_cases": [
{
"input": "1\n3 2\n5 7 1\n1 2\n",
"output": "Chef\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/CLGAME"
} | vfc_4606 |
apps | verifiable_code | 1442 | Solve the following coding problem using the programming language python:
Chef is baking a cake.
While baking, in each minute the size of cake doubles as compared to its previous size.
In this cake, baking of cake is directly proportional to its size.
You are given $a$, the total time taken(in minutes) to bake the whole cake.
Let cake be half baked at $k^{th}$ minute.
Your task is to find the value of $k+2$.
-----Input:-----
- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of T test cases follows.
- The first and only line of each test case contains a single integer $a$.
-----Output:-----
For each testcase , print one line, the value of $k+2$.
-----Constraints-----
- $1 \leq T \leq 8 $
- $2 \leq a \leq 10^{128}$
-----Sample Input:-----
1
2
-----Sample Output:-----
3
-----Explaination-----
Time was 1 min when cake was half baked by chef so answer is 1+2=3
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
# cook your dish here
for _ in range(int(input())):
a=int(input())
print(a/2+2)
``` | {
"language": "python",
"test_cases": [
{
"input": "1\n2\n",
"output": "3\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/ECPG2020/problems/ECPC10C"
} | vfc_4610 |
apps | verifiable_code | 1443 | Solve the following coding problem using the programming language python:
Once N boys and M girls attended a party. You are given a matrix A of N rows and M columns where Aij is 1 if the i-th boy likes the j-th girl, otherwise it will be 0. Note that it is not necessary that if a boy x likes girl y, then girl y should like boy x.
You know that if there are two different boys x and y, who both like girl z, then there will be a collision.
Can you calculate the number of different collisions at this party? Note that order of boys in the collision doesn't matter.
-----Input-----
The first line contains a single integer T denoting the number of test cases. Then T test cases follow.
The first line of each test case contains two space separated integers N, M denoting the number of boys and girls, respectively.
Each of the following N lines contain M characters, each of them is either '0' or '1'.
-----Output-----
For each test case output a single line containing an integer corresponding to the number of collisions at the party.
-----Constraints-----
- 1 ≤ T ≤ 100
- 1 ≤ N, M ≤ 10
-----Example-----
Input:
2
4 3
111
100
110
000
2 2
10
01
Output:
4
0
-----Explanation-----
Example Case 1. All three boys like the first girl, so there are (1, 2, 1), (1, 3, 1), (2, 3, 1) collisions with her. Boys 1 and 3 both like the second girl so this is one more collision. Only one boy likes the third girl, so there are no collisions with her and thus we have 4 collisions total.
Example Case 2. For each girl there is only one boy who likes her, so there are no collisions at all.
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,k=map(int,input().split())
m=[]
for j in range(n):
l=list(input())
m.append(l)
a=0
for k in range(k):
b=0
for p in range(n):
if m[p][k]=='1':
b+=1
if b>1:
a+=((b*(b-1))//2)
print(a)
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n4 3\n111\n100\n110\n000\n2 2\n10\n01\n",
"output": "4\n0\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/LCOLLIS"
} | vfc_4614 |
apps | verifiable_code | 1444 | Solve the following coding problem using the programming language python:
Chef is a big fan of soccer! He loves soccer so much that he even invented soccer for dogs! Here are the rules of soccer for dogs:
- N$N$ dogs (numbered 1$1$ through N$N$) stand in a line in such a way that for each valid i$i$, dogs i$i$ and i+1$i + 1$ are adjacent.
- Each dog has a skill level, which is either 1$1$ or 2$2$.
- At the beginning of the game, Chef passes a ball to dog 1$1$ (dog 1$1$ receives the ball).
- For each valid i$i$, if dog i$i$ has skill level s$s$, this dog can pass the ball to any dog with number j$j$ such that 1≤|i−j|≤s$1 \le |i-j| \le s$.
- Each dog (including dog 1$1$) may receive the ball at most once.
- Whenever a dog receives the ball, it must either pass it to another dog or finish the game by scoring a goal.
While the dogs were playing, Chef also created a game for developers. He defined the result of a game of soccer for dogs as the sequence of dogs which received the ball in the order in which they received it. The last dog in the sequence is the dog that decided to score a goal; if a dog never received the ball, it does not appear in the sequence. In the game for developers, you should find the number of possible results of soccer for dogs.
Find this number of possible results modulo 109+7$10^9 + 7$. Two results of soccer for dogs (sequences of dogs' numbers) are considered different if these sequences have different lengths or if there is a valid index i$i$ such that the i$i$-th dog in one sequence is different from the i$i$-th dog in the other sequence.
-----Input-----
- The first line of the input contains a single integer T$T$ denoting the number of test cases. The description of T$T$ test cases follows.
- The first line of each test case contains a single integer N$N$.
- The second line contains N$N$ space-separated integers A1,A2,…,AN$A_1, A_2, \ldots, A_N$ denoting the skill levels of the dogs.
-----Output-----
For each test case, print a single line containing one integer - the number of different results of soccer for dogs, modulo 109+7$10^9 + 7$.
-----Constraints-----
- 1≤T≤10$1 \le T \le 10$
- 1≤N≤105$1 \le N \le 10^5$
- 1≤Ai≤2$1 \le A_i \le 2$ for each valid i$i$
-----Subtasks-----
Subtask #1 (10 points): N≤10$N \le 10$
Subtask #2 (30 points): N≤103$N \le 10^3$
Subtask #3 (60 points): original constraints
-----Example Input-----
3
4
1 1 1 1
3
2 2 2
4
1 2 1 1
-----Example Output-----
4
5
6
-----Explanation-----
Example case 1: The following results are possible: 1$1$, [1,2]$[1, 2]$, [1,2,3]$[1, 2, 3]$, [1,2,3,4]$[1, 2, 3, 4]$.
Example case 2: The following results are possible: [1]$[1]$, [1,2]$[1, 2]$, [1,2,3]$[1, 2, 3]$, [1,3,2]$[1, 3, 2]$, [1,3]$[1, 3]$.
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())):
num=int(input())
arr=list(map(int,input().split()))
dp=[0]*num
dp[0]=1
ans=1
j=0
for i in range(1,num):
j=i+1
count=1
dp[i]=dp[i-1]%1000000007
if i-2>=0 and arr[i-2]==2:
dp[i]+=dp[i-2]%1000000007
if i-3>=0 and arr[i-3]==2:
dp[i]+=dp[i-3]
ans+=dp[i]%1000000007
if arr[i-1]==2 and i<num-1:
if i>=j or j==0:
j=i+1
while j<num and arr[j]==2:
j+=1
count=j-i
while j<len(arr) and arr[j]==2:
j+=1
count+=1
if j==num:
ans+=dp[i-1]*(count-1)%1000000007
elif count%2!=0:
if j<num-1 and arr[j+1]==2:
ans+=dp[i-1]*(count+1)%1000000007
else:
ans+=dp[i-1]*(count)%1000000007
elif count%2==0:
ans+=dp[i-1]*(count-1)%1000000007
print(ans%1000000007)
``` | {
"language": "python",
"test_cases": [
{
"input": "3\n4\n1 1 1 1\n3\n2 2 2\n4\n1 2 1 1\n",
"output": "4\n5\n6\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/CHEFSOC"
} | vfc_4618 |
apps | verifiable_code | 1446 | Solve the following coding problem using the programming language python:
Given an integer N, Chef wants to find the smallest positive integer M such that the bitwise XOR of M and M+1 is N. If no such M exists output -1.
-----Input-----
The first line of input contain an integer T denoting the number of test cases. Each of the following T lines contains an integer N for that test case.
-----Output-----
For each test case, output a single line containing the number M or -1 as described above.
-----Constraints-----
- 1 ≤ T ≤ 5000
- 1 ≤ N ≤ 230
-----Example-----
Input:
1
3
Output:
1
-----Explanation-----First Example : M desired in the problem would be 1. As bitwise XOR of 1 and 2 is equal to 3.
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 log2
# N = 10000
# for i in range(1,N):
# # print(i)
# for m in range(i):
# if( (m^(m+1))==i ):
# print(i)
# print(m,m+1,bin(m)[2:])
# print()
# break
# # else:
# # print(-1)
# # print()
T = int(input())
ans = []
for _ in range(T):
N = int(input())
# x = log2(N+1)
if(N==1):
ans.append(2)
elif('0' not in bin(N)[2:]):
ans.append(N//2)
else:
ans.append(-1)
for i in ans:
print(i)
``` | {
"language": "python",
"test_cases": [
{
"input": "1\n3\n",
"output": "1\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/XORNUBER"
} | vfc_4626 |
apps | verifiable_code | 1447 | Solve the following coding problem using the programming language python:
In Chefland, types of ingredients are represented by integers and recipes are represented by sequences of ingredients that are used when cooking. One day, Chef found a recipe represented by a sequence $A_1, A_2, \ldots, A_N$ at his front door and he is wondering if this recipe was prepared by him.
Chef is a very picky person. He uses one ingredient jar for each type of ingredient and when he stops using a jar, he does not want to use it again later while preparing the same recipe, so ingredients of each type (which is used in his recipe) always appear as a contiguous subsequence. Chef is innovative, too, so he makes sure that in each of his recipes, the quantity of each ingredient (i.e. the number of occurrences of this type of ingredient) is unique ― distinct from the quantities of all other ingredients.
Determine whether Chef could have prepared the given recipe.
-----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 the string "YES" if the recipe could have been prepared by Chef or "NO" otherwise (without quotes).
-----Constraints-----
- $1 \le T \le 100$
- $1 \le N \le 10^3$
- $1 \le A_i \le 10^3$ for each valid $i$
-----Example Input-----
3
6
1 1 4 2 2 2
8
1 1 4 3 4 7 7 7
8
1 7 7 3 3 4 4 4
-----Example Output-----
YES
NO
NO
-----Explanation-----
Example case 1: For each ingredient type, its ingredient jar is used only once and the quantities of all ingredients are pairwise distinct. Hence, this recipe could have been prepared by Chef.
Example case 2: The jar of ingredient $4$ is used twice in the recipe, so it was not prepared by Chef.
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())):
n=int(input())
arr=list(map(int,input().split()))
d={}
s=set()
flag=0
for i in range(n):
if arr[i] in list(d.keys()):
d[arr[i]]+=1
else:
d[arr[i]]=1
curr_ele=arr[i]
if (curr_ele in s) and arr[i-1]!=arr[i]:
flag=1
break
else:
s.add(arr[i])
c=list(d.values())
if len(c)!=len(set(c)):
flag=1
if flag==1:
print("NO")
else:
print("YES")
``` | {
"language": "python",
"test_cases": [
{
"input": "3\n6\n1 1 4 2 2 2\n8\n1 1 4 3 4 7 7 7\n8\n1 7 7 3 3 4 4 4\n",
"output": "YES\nNO\nNO\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/CHEFRECP"
} | vfc_4630 |
apps | verifiable_code | 1448 | Solve the following coding problem using the programming language python:
Kshitij has recently started solving problems on codechef. As he is real problem solving enthusiast, he wants continuous growth in number of problems solved per day.
He started with $a$ problems on first day.
He solves $d$ problems more than previous day. But after every $k$ days , he increases $d$ by
$inc$ .
Can you guess how many questions he will solve on $nth $ day ?
-----Input:-----
- First line contains $T$, number of testcases. Then the testcases follow.
- Each testcase contains of a single line of input,five integers $a, d, k, n, inc$.
-----Output:-----
For each testcase, output in a single line number of questions solved on $nth$ day.
-----Constraints-----
- $1 \leq T \leq 15$
- $1 \leq a \leq 99$
- $1 \leq d \leq 100$
- $1 \leq n \leq 10000$
- $1 \leq k \leq n$
- $0 \leq inc \leq 99$
-----Sample Input:-----
1
1 4 3 8 2
-----Sample Output:-----
43
-----EXPLANATION:-----
The number of questions solved in first 8 days is :
$1$ $5$ $9$ $15$ $21$ $27$ $35$ $43$ .
On first day he solved 1 problem . Here $d$ is 4 for first 3 days.
Then after 3 days $d$ increases by 2 (that is 6).
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
# cook your dish here
t = int(input())
for _ in range(t):
a,d,k,n,inc = map(int, input().strip().split())
res = a
for i in range(1, n):
if i%k == 0:
d += inc
res += d
print(res)
``` | {
"language": "python",
"test_cases": [
{
"input": "1\n1 4 3 8 2\n",
"output": "43\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/CFUS2020/problems/CFS2001"
} | vfc_4634 |
apps | verifiable_code | 1449 | Solve the following coding problem using the programming language python:
A Little Elephant from the Zoo of Lviv likes lucky strings, i.e., the strings that consist only of the lucky digits 4 and 7.
The Little Elephant calls some string T of the length M balanced if there exists at least one integer X (1 ≤ X ≤ M) such that the number of digits 4 in the substring T[1, X - 1] is equal to the number of digits 7 in the substring T[X, M]. For example, the string S = 7477447 is balanced since S[1, 4] = 7477 has 1 digit 4 and S[5, 7] = 447 has 1 digit 7. On the other hand, one can verify that the string S = 7 is not balanced.
The Little Elephant has the string S of the length N. He wants to know the number of such pairs of integers (L; R) that 1 ≤ L ≤ R ≤ N and the substring S[L, R] is balanced. Help him to find this number.
Notes.
Let S be some lucky string. Then
- |S| denotes the length of the string S;
- S[i] (1 ≤ i ≤ |S|) denotes the ith character of S (the numeration of characters starts from 1);
- S[L, R] (1 ≤ L ≤ R ≤ |S|) denotes the string with the following sequence of characters: S[L], S[L + 1], ..., S[R], and is called a substring of S. For L > R we mean by S[L, R] an empty string.
-----Input-----
The first line of the input file contains a single integer T, the number of test cases. Each of the following T lines contains one string, the string S for the corresponding test case. The input file does not contain any whitespaces.
-----Output-----
For each test case output a single line containing the answer for this test case.
-----Constraints-----
1 ≤ T ≤ 10
1 ≤ |S| ≤ 100000
S consists only of the lucky digits 4 and 7.
-----Example-----
Input:
4
47
74
477
4747477
Output:
2
2
3
23
-----Explanation-----
In the first test case balance substrings are S[1, 1] = 4 and S[1, 2] = 47.
In the second test case balance substrings are S[2, 2] = 4 and S[1, 2] = 74.
Unfortunately, we can't provide you with the explanations of the third and the fourth test cases. You should figure it out by yourself. Please, don't ask about this in comments.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
x=eval(input())
for x in range(0,x):
ans=0
d=input()
a=0
cont=0
for i in range(0,len(d)):
a+=len(d)-i
if d[i]=='7':
ans+=1+cont
cont+=1
else:
cont=0
ans=a-ans
print(ans)
``` | {
"language": "python",
"test_cases": [
{
"input": "4\n47\n74\n477\n4747477\n\n\n",
"output": "2\n2\n3\n23\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/COOK22/problems/LUCKYBAL"
} | vfc_4638 |
apps | verifiable_code | 1450 | Solve the following coding problem using the programming language python:
Cheffina challanges chef to rearrange the given array as arr[i] > arr[i+1] < arr[i+2] > arr[i+3].. and so on…, i.e. also arr[i] < arr[i+2] and arr[i+1] < arr[i+3] and arr[i] < arr[i+3] so on.. Chef accepts the challenge, chef starts coding but his code is not compiling help him to write new code.
-----Input:-----
- First-line will contain $T$, the number of test cases. Then the test cases follow.
- Each test case contains two lines of input, First $N$ as the size of the array.
- N space-separated distinct integers.
-----Output:-----
For each test case, output in a single line answer given to the Chefffina.
-----Constraints-----
- $1 \leq T \leq 10$
- $1 \leq N \leq 10^5$
- $1 \leq arr[i] \leq 10^5$
-----Sample Input:-----
2
4
4 1 6 3
5
4 5 1 6 3
-----Sample Output:-----
3 1 6 4
3 1 5 4 6
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
# cook your dish here
for _ in range(int(input())):
n = int(input())
a = list(map(int,input().split()))
a.sort()
i=1
while(i<n):
a[i-1],a[i] = a[i],a[i-1]
i+=2
print(*a)
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n4\n4 1 6 3\n5\n4 5 1 6 3\n",
"output": "3 1 6 4\n3 1 5 4 6\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/PBK32020/problems/ITGUY30"
} | vfc_4642 |
apps | verifiable_code | 1451 | Solve the following coding problem using the programming language python:
There is only little time left until the New Year! For that reason, Chef decided to make a present for his best friend. He made a connected and undirected simple graph with N$N$ vertices and M$M$ edges.
Since Chef does not like odd numbers and his friend does not like undirected graphs, Chef decided to direct each edge in one of two possible directions in such a way that the indegrees of all vertices of the resulting graph are even. The indegree of a vertex is the number of edges directed to that vertex from another vertex. As usual, Chef is busy in the kitchen, so you need to help him with directing the edges. Find one possible way to direct them or determine that it is impossible under the given conditions, so that Chef could bake a cake as a present instead.
-----Input-----
- The first line of the input contains a single integer T$T$ denoting the number of test cases. The description of T$T$ test cases follows.
- The first line of each test case contains two space-separated integers N$N$ and M$M$.
- M$M$ lines follow. For each i$i$ (1≤i≤M$1 \le i \le M$), the i$i$-th of these lines contains two space-separated integers ui$u_i$ and vi$v_i$ denoting an edge between vertices ui$u_i$ and vi$v_i$.
-----Output-----
For each test case:
- If a valid way to direct the edges does not exist, print a single line containing one integer −1$-1$.
- Otherwise, print a single line containing M$M$ space-separated integers. For each valid i$i$, the i$i$-th of these integers should be 0$0$ if edge i$i$ is directed from ui$u_i$ to vi$v_i$ or 1$1$ if it is directed from vi$v_i$ to ui$u_i$.
-----Constraints-----
- 1≤T≤5$1 \le T \le 5$
- 1≤N,M≤105$1 \le N, M \le 10^5$
- 1≤ui,vi≤N$1 \le u_i, v_i \le N$ for each valid i$i$
- the graph on the input is connected, does not contain multiple edges or self-loops
-----Subtasks-----
Subtask #1 (30 points): 1≤N,M≤1,000$1 \le N, M \le 1,000$
Subtask #2 (70 points): original constraints
-----Example Input-----
2
4 4
1 2
1 3
2 4
3 4
3 3
1 2
2 3
1 3
-----Example Output-----
0 0 1 1
-1
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
# cook your dish here
for _ in range(int(input())):
N, M = [int(x) for x in input().split()]
edges = [0]*M
dir = {}
nodes = [[] for j in range(N+1)]
ind = [0]*(N+1)
graph = {}
final_edges = []
for i in range(M):
u, v = [int(x) for x in input().split()]
nodes[u].append(v)
nodes[v].append(u)
dir[(u,v)]=1
dir[(v,u)] = 0
ind[v] += 1
graph[(u,v)] = graph[(v,u)] = i
final_edges.append([u,v])
if M%2!=0:
print(-1)
continue
for i in range(M):
u, v = final_edges[i]
if ind[u]%2!=0 and ind[v]%2!=0:
d = dir[(u,v)]
if d:
ind[u] += 1
ind[v] -= 1
dir[(u,v)] = 0
dir[(v,u)] = 1
edges[i] = abs(edges[i]-1)
else:
ind[u] -= 1
ind[v] += 1
dir[(u, v)] = 1
dir[(v, u)] = 0
edges[i] = abs(edges[i]-1)
s = []
for i in range(1, N+1):
if ind[i]%2:
s.append(i)
while s:
set1 = set()
for u in s:
if ind[u]%2:
v = nodes[u][0]
d = dir[(u,v)]
index = graph[(u, v)]
set1.add(v)
if d:
ind[u] += 1
ind[v] -= 1
dir[(u, v)] = 1
dir[(v, u)] = 1
edges[index] = abs(edges[index]-1)
else:
ind[u] -= 1
ind[v] += 1
dir[(u, v)] = 1
dir[(v, u)] = 0
edges[index] = abs(edges[index]-1)
s = set1
print(*edges)
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n4 4\n1 2\n1 3\n2 4\n3 4\n3 3\n1 2\n2 3\n1 3\n",
"output": "0 0 1 1\n-1\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/EDGEDIR"
} | vfc_4646 |
apps | verifiable_code | 1452 | Solve the following coding problem using the programming language python:
Chef has bought N robots to transport cakes for a large community wedding. He has assigned unique indices, from 1 to N, to each of them. How it will happen?
Chef arranges the N robots in a row, in the (increasing) order of their indices. Then, he chooses the first M robots and moves them to the end of the queue. Now, Chef goes to the robot at the first position in the row and hands it one cake. He then notes this robot's index (say k) in his notebook, and goes to the kth position in the row. If the robot at this position does not have a cake, he give him one cake, notes his index in his notebook, and continues the same process. If a robot visited by Chef already has a cake with it, then he stops moving and the cake assignment process is stopped.
Chef will be satisfied if all robots have a cake in the end. In order to prepare the kitchen staff for Chef's wrath (or happiness :) ), you must find out if he will be satisfied or not? If not, you have to find out how much robots have a cake, so that the kitchen staff can prepare themselves accordingly.
-----Input-----
- The first line of input contains a single integer T denoting the number of test cases.
- The single line of each test cases contains two space separated integers N and M.
-----Output-----
For each of the T test cases, output a single line:
- If all N robots have a cake, output "Yes" (without quotes).
- Otherwise, output "No" (without quotes) followed by a space and the number of robots which have a cake.
-----Constraints and Subtasks-----
- 1 ≤ T ≤ 10
- 0 ≤ M < NSubtask 1: 25 points
- 1 ≤ N ≤ 10^5Subtask 3: 75 points
- 1 ≤ N ≤ 10^9
-----Example-----
Input:
3
2 0
2 1
4 2
Output:
No 1
Yes
No 2
-----Explanation-----
In test case 1, we have two robots indexed 1 and 2. They are arranged as (1 2). Chef goes to the first robot, gives him a cake, and moves to position 1. In the next step, he sees that robot at this position already has a has cake. So Chef stops moving, and our answer is "No 1".
In test case 2, we again have two robots indexed 1 and 2. Initially, they are arranged as (1 2). Then, Chef moves robot#1 to the end of the row, and thus the arrangement becomes (2 1). Chef goes to the robot at the first position, which is robot#2. Chef hands him a cake, and moves to position 2. Then, he hands a cake to robot#1 at position 2, and moves back to the first position. Since, robot#2 at the first position already ahs a cake, Chef stops moving. All N robots have cakes, so Chef is satisfied, and our answer is "Yes".
In the 3rd test case, we have the following arrangement of robots: (3 4 1 2). Only robots with indices 3 and 1 will get cakes. So our answer is "No 2".
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
#read input
cases = int(input())
caselist = []
for i in range(0, cases):
caselist.append(input())
#iterate each case
for j in range(0, cases):
#current case's parameters:
current_input = caselist[j].split(' ')
bots = int(current_input[0])
switch = int(current_input[1])
#generate botlist and cakelist
botlist = list(range(switch, bots)) + list(range(0, switch))
cakelist = [False] * bots
counter = 0
index = 0
for i in range(0,bots):
if cakelist[index] == False:
cakelist[index] = True
counter += 1
index = botlist[index]
else:
break
if counter == bots:
print("Yes")
else:
print("No", counter)
``` | {
"language": "python",
"test_cases": [
{
"input": "3\n2 0\n2 1\n4 2\n",
"output": "No 1\nYes\nNo 2\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/NOV15/problems/EGRCAKE"
} | vfc_4650 |
apps | verifiable_code | 1453 | Solve the following coding problem using the programming language python:
Chef has a sequence $A_1, A_2, \ldots, A_N$; each element of this sequence is either $0$ or $1$. Appy gave him a string $S$ with length $Q$ describing a sequence of queries. There are two types of queries:
- '!': right-shift the sequence $A$, i.e. replace $A$ by another sequence $B_1, B_2, \ldots, B_N$ satisfying $B_{i+1} = A_i$ for each valid $i$ and $B_1 = A_N$
- '?': find the length of the longest contiguous subsequence of $A$ with length $\le K$ such that each element of this subsequence is equal to $1$
Answer all queries of the second type.
-----Input-----
- The first line of the input contains three space-separated integers $N$, $Q$ and $K$.
- The second line contains $N$ space-separated integers $A_1, A_2, \ldots, A_N$.
- The third line contains a string with length $Q$ describing queries. Each character of this string is either '?', denoting a query of the second type, or '!', denoting a query of the first type.
-----Output-----
For each query of the second type, print a single line containing one integer — the length of the longest required subsequence.
-----Constraints-----
- $1 \le K \le N \le 10^5$
- $1 \le Q \le 3 \cdot 10^5$
- $0 \le A_i \le 1$ for each valid $i$
- $S$ contains only characters '?' and '!'
-----Subtasks-----
Subtask #1 (30 points):
- $1 \le N \le 10^3$
- $1 \le Q \le 3 \cdot 10^3$
Subtask #2 (70 points): original constraints
-----Example Input-----
5 5 3
1 1 0 1 1
?!?!?
-----Example Output-----
2
3
3
-----Explanation-----
- In the first query, there are two longest contiguous subsequences containing only $1$-s: $A_1, A_2$ and $A_4, A_5$. Each has length $2$.
- After the second query, the sequence $A$ is $[1, 1, 1, 0, 1]$.
- In the third query, the longest contiguous subsequence containing only $1$-s is $A_1, A_2, A_3$.
- After the fourth query, $A = [1, 1, 1, 1, 0]$.
- In the fifth query, the longest contiguous subsequence containing only $1$-s is $A_1, A_2, A_3, A_4$ with length $4$. However, we only want subsequences with lengths $\le K$. One of the longest such subsequences is $A_2, A_3, A_4$, with length $3$.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
n, q, k = map(int, input().split())
arr = list(map(int, input().split()))
query = list(input())
q_ = len(query)
c1 = query.count('?')
c = arr.count(0)
if c == n:
for i in range(c1):
print(0)
else:
for i in range(q_):
if (i!=0) and (query[i] == '?' and query[i-1] == '?'):
print(max_c)
elif query[i] == '?':
max_c = cnt = 0
for j in range(n):
if (j != n - 1) and (arr[j] == 1 and arr[j + 1] == 1):
cnt += 1
else:
max_c = max(max_c, cnt + 1)
cnt = 0
if k < max_c:
max_c = k
break
print(max_c)
elif query[i] == '!':
temp = arr[n - 1]
del arr[n - 1]
arr.insert(0, temp)
``` | {
"language": "python",
"test_cases": [
{
"input": "5 5 3\n1 1 0 1 1\n?!?!?\n",
"output": "2\n3\n3\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/HMAPPY1"
} | vfc_4654 |
apps | verifiable_code | 1454 | Solve the following coding problem using the programming language python:
It's Christmas time and Santa is in town. There are N children each having a bag with a mission to fill in as many toffees as possible. They are accompanied by a teacher whose ulterior motive is to test their counting skills. The toffees are of different brands (denoted by lowercase letters a-z). Santa picks up a child numbered m and gives n toffees of brand p to the child.
The teacher wishes to ask the children to calculate the number of toffees there are of a particular brand amongst a given range of children. Formally, there are 2 queries:
Input:
First line consists of Q queries.
Each line follows and consists of four space separated values:
Type 1: It is of the form 1 m x p
1 is the type no,"m" is the child to which "x" toffees of a brand "p" are given
Type 2: It is of the form 2 m n p
where m - n is the range of children (inclusive) being queried for brand p
Output:
Report the sum of toffees of brand p within the given range m - n for each query of type 2
Constraints:
1 <= Q <= 10^5
1 <= N <= 10^6
1 <= m <= n <= 10^6
1 <= x <= 10^6
all brand of toffees are lowercase letters
Subtask 1: (30 points)
1 <= Q <= 10^3
1 <= m <= n <= 10^3
1 <= x <= 10^3
Subtask 2: (70 points)
Original Constraints
Sample Input:
5
1 3 4 a
1 5 8 a
1 1 7 x
2 1 6 a
2 3 6 y
Sample Output:
12
0
In first case, there are two children between 3 and 5 between 0 - 6 having sum (4 + 8)
There's no toffee for y in given range
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
import numpy as np
N=10**6+1
t=eval(input())
inp = ()
t1=ord('z')
#bag=[[0 for _ in xrange(t1)] for _ in xrange(N+1)]
bag=np.zeros((N+1,t1),dtype=np.int)
#print bag
while t:
t-=1
inp=input().split()
t2=ord(inp[3]) - ord('a')
t3=int(inp[1])
t4=int(inp[2]) + 1
if inp[0]=="1":
#print "enter"
bag[t3][t2]+=int(inp[2])
if inp[0]=="2":
sum=0
for i in range(t3,t4):
sum+=bag[i][t2]
print(sum)
#
# for j in range(ord('z')-ord('a')):
# for i in range(N+1):
# if bag[i][j]!=0:
# print bag[i][j] ,i,j
``` | {
"language": "python",
"test_cases": [
{
"input": "5\n1 3 4 a\n1 5 8 a\n1 1 7 x\n2 1 6 a\n2 3 6 y\n",
"output": "12\n0\nIn first case, there are two children between 3 and 5 between 0 - 6 having sum (4 + 8)\nThere's no toffee for y in given range\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/SIC2016/problems/SANTA"
} | vfc_4658 |
apps | verifiable_code | 1455 | Solve the following coding problem using the programming language python:
Leha is a usual student at 'The Usual University for Usual Students'. Sometimes he studies hard; at other times he plays truant and gets busy with other things besides academics. He has already studied at the university for N months. For the ith month (1 ≤ i ≤ N), he has received some non-negative integer grade A[i].
Now he wants to analyse his progress for some periods of his university education. An arbitrary period, defined by two positive integers L and R, begins at Leha's Lth month at the university and ends at the Rth. The analysis is performed via the following steps.
1. Write down all the grades for each month from L to R and sort them. Let's call the sorted list S.
2. Calculate the sum of squared differences of consecutive elements in S, that is, (S[2] - S[1])2 + (S[3] - S[2])2 + ... + (S[R-L+1] - S[R-L])2.
-----Input-----
The first line contains one integer N — the number of months Leha has already studied at the university.
The second line contains N integers — list A of Leha's grades.
The third line contains one integer M — the number of periods Leha is interested in analyzing.
Each of the following M lines contain two integers L and R describing each period.
-----Output-----
For each query, output one integer — the result of the progress analysis for the corresponding period.
-----Constraints-----
- 1 ≤ N, M ≤ 5*104
- 0 ≤ A[i] ≤ 106
-----Subtasks-----
- Subtask 1 (19 points) 1 ≤ N, M ≤ 200, time limit = 2 sec
- Subtask 2 (31 points) 1 ≤ N, M ≤ 10 000, time limit = 2 sec
- Subtask 3 (26 points) 0 ≤ A[i] ≤ 100, time limit = 5 sec
- Subtask 4 (24 points) no additional constraints, , time limit = 5 sec
-----Example-----
Input:5
1 3 2 4 5
5
1 5
1 4
2 4
3 3
3 5
Output:4
3
2
0
5
Explanation
The first query: sorted array looks like (1, 2, 3, 4, 5) and the answer is calculated as (2-1)2 + (3-2)2 + (4-3)2 + (5-4)2 = 4
The second query: sorted array looks like (1, 2, 3, 4) and the answer is calculated as (2-1)2 + (3-2)2 + (4-3)2 = 3
The last query: sorted array looks like (2, 4, 5) and the answer is calculated as (4-2)2 + (5-4)2 = 5
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
n=eval(input())
grades=list(map(int,input().split()))
m=eval(input())
for df in range(m):
x,y=list(map(int,input().split()))
arr=[]
arr=grades[x-1:y]
arr.sort()
sum=0
#arr.append(1000000)
for nh in range(0,len(arr)-1,1):
sum=sum+(arr[nh+1]-arr[nh])**2
#print sum,len(arr),nh+1,nh
print(sum)
``` | {
"language": "python",
"test_cases": [
{
"input": "5\n1 3 2 4 5\n5\n1 5\n1 4\n2 4\n3 3\n3 5\n",
"output": "4\n3\n2\n0\n5\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/LTIME29/problems/STDPRGS"
} | vfc_4662 |
apps | verifiable_code | 1456 | Solve the following coding problem using the programming language python:
The XOR pair representation (XPR) of a positive integer $N$ is defined as a pair of integers $(A, B)$ such that:
- $1 \le A \le B \le N$
- $A \oplus B = N$
- if there is no way to choose $A$ and $B$ satisfying the above conditions, $A = B = -1$
- otherwise, the value of $A$ should be the smallest possible
These conditions uniquely define the XPR. Next, we define a function $F(N)$ = the value of $B$ in $XPR(N)$, and a function $G(L, R) = \sum\limits_{i=L}^R F(i)$.
You are given $L$ and $R$. Compute $G(L, R)$.
-----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 $L$ and $R$.
-----Output-----
For each test case, print a single line containing one integer — the value of the function $G(L, R)$.
-----Constraints-----
- $1 \le T \le 10^5$
- $1 \le L \le R \le 10^9$
-----Example Input-----
5
1 10
3 6
4 10
10 17
100 159
-----Example Output-----
28
9
28
79
7485
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 GLR(x):
summation_N = (x*(x+1))//2
initial = x
power = 0
sum_A = 0
while x>=1:
count = (x+1)//2
sum_A += count * 2**power
x = x - count
power += 1
sum_B = summation_N - sum_A
ans = sum_B - (int(math.log(initial,2))+1)
return ans
for _ in range(int(input())):
l,r = list(map(int,input().split()))
if l==1:
print(GLR(r))
else:
print((GLR(r) - GLR(l-1)))# cook your dish here
``` | {
"language": "python",
"test_cases": [
{
"input": "5\n1 10\n3 6\n4 10\n10 17\n100 159\n",
"output": "28\n9\n28\n79\n7485\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/XORIT"
} | vfc_4666 |
apps | verifiable_code | 1457 | Solve the following coding problem using the programming language python:
The purpose of this problem is to verify whether the method you are using to read input data is sufficiently fast to handle problems branded with the enormous Input/Output warning. You are expected to be able to process at least 2.5MB of input data per second at runtime.
-----Input-----
The input begins with two positive integers n k (n, k<=107). The next n lines of input contain one positive integer ti, not greater than 109, each.
-----Output-----
Write a single integer to output, denoting how many integers ti are divisible by k.
-----Example-----
Input:
7 3
1
51
966369
7
9
999996
11
Output:
4
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
#Note that it's python3 Code. Here, we are using input() instead of raw_input().
#You can check on your local machine the version of python by typing "python --version" in the terminal.
(n, k) = list(map(int, input().split(' ')))
ans = 0
for i in range(n):
x = int(input())
if x % k == 0:
ans += 1
print(ans)
``` | {
"language": "python",
"test_cases": [
{
"input": "7 3\n1\n51\n966369\n7\n9\n999996\n11\n",
"output": "4\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/INTEST"
} | vfc_4670 |
apps | verifiable_code | 1458 | Solve the following coding problem using the programming language python:
Chef has recently been playing a lot of chess in preparation for the ICCT (International Chef Chess Tournament).
Since putting in long hours is not an easy task, Chef's mind wanders elsewhere. He starts counting the number of squares with odd side length on his chessboard..
However, Chef is not satisfied. He wants to know the number of squares of odd side length on a generic $N*N$ chessboard.
-----Input:-----
- The first line will contain a single integer $T$, the number of test cases.
- The next $T$ lines will have a single integer $N$, the size of the chess board.
-----Output:-----
For each test case, print a integer denoting the number of squares with odd length.
-----Constraints-----
- $1 \leq T \leq 100$
- $1 \leq N \leq 1000$
-----Sample Input:-----
2
3
8
-----Sample Output:-----
10
120
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):
a=0
n=int(input())
while(n>0):
a += n*n
n=n-2
print(a)
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n3\n8\n",
"output": "10\n120\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/PCJ18B"
} | vfc_4674 |
apps | verifiable_code | 1459 | Solve the following coding problem using the programming language python:
Today, Chef has a fencing job at hand and has to fence up a surface covering N$N$ points.
To minimize his work, he started looking for an algorithm that had him fence the least amount of length.
He came up with the Convex Hull algorithm, but soon realized it gave him some random shape to fence. However, Chef likes rectangles and has a favourite number M$M$.
Help him find the minimum perimeter he has to fence if he wants to fence a rectangle, with slope of one of the sides as M$M$, to cover all the points.
-----Input:-----
- The first line contains two integers N$N$ and M$M$, the number of points and the Chef's favourite Number.
- The next n lines contain two space separated integers X$X$ and Y$Y$, the coordinates of the point.
-----Output:-----
Print a single decimal number, denoting the perimeter of the rectangle. Answer will considered correct if it has absolute error less than 10−6$10^{-6}$.
-----Constraints-----
- 2≤N≤1000000$2 \leq N \leq 1000000$
- −1000≤M≤1000$-1000 \leq M \leq 1000$
- −1000000≤X≤1000000$-1000000 \leq X \leq 1000000$
- −1000000≤Y≤1000000$-1000000 \leq Y \leq 1000000$
-----Sample Input:-----
4 1
0 1
0 -1
1 0
-1 0
-----Sample Output:-----
5.656854249492380
-----Note:-----
- As the input size is large, it is recommended to use Fast IO.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
import math
n,m = map(int, input().split())
hyp = math.sqrt(1+m*m)
cosx = 1/hyp
sinx = m/hyp
pts = [[], []]
for i in range(n):
p = input().split()
px = int(p[0])
py = int(p[1])
pts[0].append(cosx*px+sinx*py)
pts[1].append(cosx*py-sinx*px)
w = max(pts[0])-min(pts[0])
l = max(pts[1])-min(pts[1])
print(2*l+2*w)
``` | {
"language": "python",
"test_cases": [
{
"input": "4 1\n 0 1\n 0 -1\n 1 0\n -1 0\n\n",
"output": "5.656854249492380\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/PCJ18F"
} | vfc_4678 |
apps | verifiable_code | 1460 | Solve the following coding problem using the programming language python:
Mia is working as a waitress at a breakfast diner. She can take up only one shift from 6 shifts a day i.e. from 10 am to 4 pm. She needs to save 300$ after completion of the month. She works only for $D$ days in the month. She estimates that she gets her highest tip in the first shift and the tip starts decreasing by 2% every hour as the day prolongs. She gets a minimum wage of $X$ $ for every shift. And her highest tip in the first shift is $Y$ $. Determine whether Mia will be able to save 300$ from her wages and tips after working $D$ days of the month. If she can, print YES, else print NO.
-----Constraints-----
- 8 <= D <=30
- 7 <= X <=30
- 4 <= Y <= 20
-----Input:-----
- First line has three parameters $D$, $X$ and $Y$ i.e. number of days worked, minimum wage and highest tip.
- Second line contains D integers indicating her shifts every $i$-th day she has worked.
-----Output:-----
- Print YES, if Mia has saved 300$, NO otherwise.
-----Sample Input:-----
9 17 5
1 3 2 4 5 6 1 2 2
-----Sample Output:-----
NO
-----Explanation:-----
No. of days Mia worked (D) is 9, so minimum wage she earns (X) is 17 dollars. Highest tip at first hour (Y) = 5 dollars, 1st day she took 1st shift and 2nd day she took 3rd shift and so on. Upon calculation we will find that Mia was not able to save 300 dollars.
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
l=[int(k) for k in input().split()]
s=[int(k) for k in input().split()]
x=l[1]*l[0]
for i in range(l[0]):
if(s[i]==1):
x+=l[2]
elif(s[i]==2):
x+=(l[2]*98/100)
elif(s[i]==3):
x+=(l[2]*96/100)
elif(s[i]==4):
x+=(l[2]*94/100)
elif(s[i]==5):
x+=(l[2]*92/100)
elif(s[i]==6):
x+=(l[2]*90/100)
if(x>=300):
print("YES")
else:
print("NO")
``` | {
"language": "python",
"test_cases": [
{
"input": "9 17 5\n1 3 2 4 5 6 1 2 2\n",
"output": "NO\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/TAWY2020/problems/TAWY002"
} | vfc_4682 |
apps | verifiable_code | 1461 | Solve the following coding problem using the programming language python:
Consider the fraction, $a/b$, where $a$ and $b$ are positive integers. If $a < b$ and $GCD(a,b) = 1$, it is called a reduced proper fraction.
If we list the set of a reduced proper fraction for $d \leq 8$, (where $d$ is the denominator) in ascending order of size, we get:
$1/8$, $1/7$, $1/6$, $1/5$, $1/4$, $2/7$, $1/3$, $3/8$, $2/5$ , $3/7$, $1/2$, $4/7$, $3/5$, $5/8$, $2/3$, $5/7$, $3/4$, $4/5$, $5/6$, $6/7$, $7/8$
It can be seen that $2/5$ is the fraction immediately to the left of $3/7$.
By listing the set of reduced proper fractions for $d \leq N$ in ascending order of value, find the numerator and denominator of the fraction immediately to the left of $a/b$ when $a$ and $b$ are given.
-----Input:-----
- First line of input contains an integer $T$, number of test cases
- Next $T$ lines contain $a$ $b$ $N$ separated by space
-----Output:-----
Print the numerator and denominator separated by a space corresponding to each test case on a new line
-----Constraints-----
- $1 \leq T \leq 50$
- $1 \leq a < b \leq 10^9$
- $GCD(a,b) = 1$
- $b < N \leq 10^{15}$
-----Subtasks-----
- 10 points: $1 \leq N \leq 100$
- 30 points : $1 \leq N \leq 10^6$
- 60 points : $1 \leq N \leq 10^{15}$
-----Sample Input:-----
5
3 7 8
3 5 8
4 5 8
6 7 8
1 5 8
-----Sample Output:-----
2 5
4 7
3 4
5 6
1 6
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
from fractions import Fraction
input = stdin.readline
for _ in range(int(input())):
a, b, n = list(map(int, input().split()))
ab = Fraction(a, b)
p = set()
for i in range(1, n+1):
for j in range(n, 0, -1):
x = Fraction(i, j)
if x > ab:
break
p.add(x)
x = sorted(p)[-2]
print(x.numerator, x.denominator)
``` | {
"language": "python",
"test_cases": [
{
"input": "5\n3 7 8\n3 5 8\n4 5 8\n6 7 8\n1 5 8\n",
"output": "2 5\n4 7\n3 4\n5 6\n1 6\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/QTST2020/problems/NEGBFRAC"
} | vfc_4686 |
apps | verifiable_code | 1462 | Solve the following coding problem using the programming language python:
The name of our college is "Government College of Engineering and Textile Technology Berhampore". There is another college named "Government College of Engineering and Textile Technology Serampore". As the names are quite similar, those who are unaware of existence of both the colleges, often get confused. And mistake one with other.
Given a string, if it contains the word berhampore (case insensitive), print GCETTB or if it contains serampore(case-insensitive), print GCETTS . If the string contains neither print Others. If it contains both Berhampore and Serampore print Both
Input
- First line contains single integer T, No. of test case
- Next line for every test contain case a string S
Output
Print GCETTB or GCETTS or Others or Both on a new line
Constraints
- 1 <= T <= 10
- 0 <= len(S) <= 100
- S contain a-z and A-Z and space only
Sample Input
3
Government clg Berhampore
SeRaMporE textile college
Girls college Kolkata
Sample Output
GCETTB
GCETTS
Others
Explanation
Self-Explanatory
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):
n=input()
n=n.lower()
a="berhampore"
b="serampore"
if a in n:
if b in n:
print("Both")
else:
print("GCETTB")
elif b in n:
if a in n:
print("Both")
else:
print("GCETTS")
else:
print("Others")
except Exception as e:
pass
``` | {
"language": "python",
"test_cases": [
{
"input": "3\nGovernment clg Berhampore\nSeRaMporE textile college\nGirls college Kolkata\n",
"output": "GCETTB\nGCETTS\nOthers\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/COMT2020/problems/BHPORSRP"
} | vfc_4690 |
apps | verifiable_code | 1463 | Solve the following coding problem using the programming language python:
Chef has a recipe book. He wishes to read it completely as soon as possible so that he could try to cook the dishes mentioned in the book.
The pages of the book are numbered $1$ through $N$. Over a series of days, Chef wants to read each page. On each day, Chef can choose to read any set of pages such that there is no prime that divides the numbers of two or more of these pages, i.e. the numbers of pages he reads on the same day must be pairwise coprime. For example, Chef can read pages $1$, $3$ and $10$ on one day, since $(1, 3)$, $(3, 10)$ and $(1, 10)$ are pairs of coprime integers; however, he cannot read pages $1$, $3$ and $6$ on one day, as $3$ and $6$ are both divisible by $3$. Since chef might get bored by reading the same recipe again and again, Chef will read every page exactly once.
Given $N$, determine the minimum number of days Chef needs to read the entire book and the pages Chef should read on each 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 and only line of each test case contains a single integer $N$.
-----Output-----
For each test case:
- First, print a line containing a single integer $D$ ― the minimum number of days required to read the book. Let's number these days $1$ through $D$.
- Then, print $D$ lines describing the pages Chef should read. For each valid $i$, the $i$-th of these lines should contain an integer $C_i$ followed by a space and $C_i$ space-separated integers ― the numbers of pages Chef should read on the $i$-th day.
If there are multiple solutions with the minimum number of days, you may print any one.
-----Constraints-----
- $1 \le T \le 10$
- $1 \le N \le 10^6$
-----Subtasks-----
Subtask #1 (20 points): $N \le 100$
Subtask #2 (80 points): original constraints
-----Example Input-----
1
5
-----Example Output-----
2
3 1 2 5
2 3 4
-----Explanation-----
Example case 1:
- On the first day, Chef should read three pages: $1$, $2$ and $5$.
- On the second day, Chef should read the remaining two pages: $3$ and $4$.
There are other valid solutions as well.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
def ugcd(n):
ans = [[1]]
if(n==1):
return ans
elif(n%2==1):
ans = [[1, 2, n]]
else:
ans = [[1, 2]]
for k in range(1, int(n//2)):
ans.append([k*2+1, k*2+2])
return ans
t = int(input())
for i in range(t):
n = int(input())
s = (ugcd(n))
print(len(s))
for j in range(len(s)):
print(len(s[j]), end=" ")
print(*s[j])
``` | {
"language": "python",
"test_cases": [
{
"input": "1\n5\n\n",
"output": "2\n3 1 2 5\n2 3 4\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/UNITGCD"
} | vfc_4694 |
apps | verifiable_code | 1464 | Solve the following coding problem using the programming language python:
You visit a doctor on a date given in the format $yyyy:mm:dd$. Your doctor suggests you to take pills every alternate day starting from that day. You being a forgetful person are pretty sure won’t be able to remember the last day you took the medicine and would end up in taking the medicines on wrong days.
So you come up with the idea of taking medicine on the dates whose day is odd or even depending on whether $dd$ is odd or even. Calculate the number of pills you took on right time before messing up for the first time.
-----Note:-----
Every year that is exactly divisible by four is a leap year, except for years that are exactly divisible by 100; the centurial years that are exactly divisible by 400 are still leap years. For example, the year 1900 is not a leap year; the year 2000 is a leap year.
-----Input:-----
- First line will contain $T$, number of testcases. Then the testcases follow.
- Each testcase contains of a single line of input, in the format $yyyy:mm:dd$
-----Output:-----
For each testcase, output in a single line the required answer.
-----Constraints-----
- $ 1 \leq T \leq 1000 $
- $ 1900 \leq yyyy \leq 2038 $
- $yyyy:mm:dd$ is a valid date
-----Sample Input:-----
1
2019:03:31
-----Sample Output:-----
1
-----EXPLANATION:-----
You can take pill on the right day only on 31st March. Next you will take it on 1st April which is not on the alternate day.
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())
li1=[31,29,31,30,31,30,31,31,30,31,30,31]
li2=[31,28,31,30,31,30,31,31,30,31,30,31]
for z in range(t):
y,m,d=list(map(int,input().split(':')))
if y%4 == 0:
if y%100 == 0:
if y%400 == 0:
li=li1
else:
li=li2
else:
li=li1
else:
li=li2
c=0
if d%2 == 0:
while d%2 == 0:
c+=1
d+=2
if d>li[m-1]:
d=d%li[m-1]
m+=1
else:
while d%2 != 0:
c+=1
d+=2
if d>li[m-1]:
d=d%li[m-1]
m+=1
print(c)
``` | {
"language": "python",
"test_cases": [
{
"input": "1\n2019:03:31\n",
"output": "1\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/MEDIC"
} | vfc_4698 |
apps | verifiable_code | 1465 | Solve the following coding problem using the programming language python:
You are given a tree consisting of n nodes numbered from 1 to n. The weights of edges of the tree can be any binary integer satisfying following Q conditions.
-
Each condition is of form u, v, x where u, v are nodes of the tree and x is a binary number.
For satisfying this condition, sum of the weight of all the edges present in the path from node u to v of the tree, should have even if x = 0, odd otherwise.
Now, you have to find out number of ways of assigning 0/1 (binary) weights to the edges of the tree satisfying the above conditions.
As the answer could be quite large, print your answer modulo 109 + 7.
-----Input-----
- The first line of input contains a single integer T denoting number of test cases.
- For each test case:
- First line contains two space separated integers n, Q.
- Each of the next n - 1 lines will contain two space separated integer u, v denoting that there is an edge between vertex u and v in the tree.
- Each of the next Q lines will contain three space separated integer u, v, x denoting a condition as stated in the probelm.
-----Output-----
- For each test case, output a single integer corresponding to the answer of the problem.
-----Constraints-----
- 1 ≤ u, v ≤ n
- 0 ≤ x ≤ 1
-----Subtasks-----
Subtask #1 : (10 points)
- Sum of each of variables n and Q over all the test cases ≤ 20
Subtask #2 : (20 points)
- Sum of each of variables n and Q over all the test cases ≤ 100
Subtask #3 : (30 points)
- Sum of each of variables n and Q over all the test cases ≤ 5000
Subtask #4 : (40 points)
- Sum of each of variables n and Q over all the test cases ≤ 100000
-----Example-----
Input:
3
3 2
1 2
1 3
1 2 0
1 3 0
3 0
1 2
2 3
3 1
1 2
2 3
1 2 1
Output:
1
4
2
-----Explanation-----
In the first example,
You can only set the weight of each edge equal to 0 for satisfying the given condition. So, there is exactly one way of doing this. Hence answer is 1.
In the second example,
There are two edges and there is no condition on the edges. So, you can assign them in 4 ways.
In the third example,
You have to assign the weight of edge between node 1 and 2 to 1. You can assign the remaining edge from 2 to 3 either 0 or 1. So, the answer is 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
def powc(x,n,m):
res = 1
xx=x
while n:
if n&1:
res = (res*xx)%m
xx=xx*xx%m
n >>= 1
return res
def circles(u):
r = 0
S = [(u,-1,0)]
Visited[u] = 0
for s in S:
for e in V[s[0]]:
if e[0] != s[1]:
if Visited[e[0]]==-1:
Visited[e[0]] = s[2]^e[1]
S.append((e[0], s[0], s[2]^e[1]))
elif Visited[e[0]] != s[2]^e[1]:
return -1
else:
r += s[0]<e[0]
return r
T = int(sys.stdin.readline())
for _ in range(T):
is_bad = False
empty = 0
n,Q = list(map(int, sys.stdin.readline().split()))
for _ in range(n-1):
sys.stdin.readline()
paths = []
V=list(map(list,[[]]*n))
for q in range(Q):
u,v,x = list(map(int, sys.stdin.readline().split()))
u-=1
v-=1
if (v,x^1) in V[u]:
is_bad = True
elif (v,x) in V[u]:
empty += 1
elif u!=v:
V[u].append((v,x))
V[v].append((u,x))
elif x==1:
is_bad = True
else:
empty += 1
paths.append((u,v,x))
if is_bad:
print(0)
elif n<=1:
print(1)
else:
Visited = [-1]*n
components = 0
for i in range(n):
if Visited[i]==-1:
components += 1
c = circles(i)
if c==-1:
is_bad = True
break
empty += c
if is_bad:
print(0)
else:
print(powc(2,n-1-(Q-empty),10**9+7))
``` | {
"language": "python",
"test_cases": [
{
"input": "3\n3 2\n1 2\n1 3\n1 2 0\n1 3 0\n3 0\n1 2\n2 3\n3 1\n1 2\n2 3\n1 2 1\n",
"output": "1\n4\n2\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/MARCH16/problems/PARITREE"
} | vfc_4702 |
apps | verifiable_code | 1466 | Solve the following coding problem using the programming language python:
Vietnamese and Bengali as well.
An $N$-bonacci sequence is an infinite sequence $F_1, F_2, \ldots$ such that for each integer $i > N$, $F_i$ is calculated as $f(F_{i-1}, F_{i-2}, \ldots, F_{i-N})$, where $f$ is some function. A XOR $N$-bonacci sequence is an $N$-bonacci sequence for which $f(F_{i-1}, F_{i-2}, \ldots, F_{i-N}) = F_{i-1} \oplus F_{i−2} \oplus \ldots \oplus F_{i−N}$, where $\oplus$ denotes the bitwise XOR operation.
Recently, Chef has found an interesting sequence $S_1, S_2, \ldots$, which is obtained from prefix XORs of a XOR $N$-bonacci sequence $F_1, F_2, \ldots$. Formally, for each positive integer $i$, $S_i = F_1 \oplus F_2 \oplus \ldots \oplus F_i$. You are given the first $N$ elements of the sequence $F$, which uniquely determine the entire sequence $S$.
You should answer $Q$ queries. In each query, you are given an index $k$ and you should calculate $S_k$. It is guaranteed that in each query, $S_k$ does not exceed $10^{50}$.
-----Input-----
- The first line of the input contains two space-separated integers $N$ and $Q$.
- The second line contains $N$ space-separated integers $F_1, F_2, \ldots, F_N$.
- The following $Q$ lines describe queries. Each of these lines contains a single integer $k$.
-----Output-----
For each query, print a single line containing one integer $S_k$.
-----Constraints-----
- $1 \le N, Q \le 10^5$
- $0 \le F_i \le 10^9$ for each $i$ such that $1 \le i \le N$
- $1 \le k \le 10^9$
-----Example Input-----
3 4
0 1 2
7
2
5
1000000000
-----Example Output-----
3
1
0
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
n,q=map(int,input().split())
ls=[int(i) for i in input().split()]
cur=0
s=[0]
for i in ls:
cur=cur^i
s.append(cur)
for i in range(q):
k=int(input())
print(s[k%(n+1)])
``` | {
"language": "python",
"test_cases": [
{
"input": "3 4\n0 1 2\n7\n2\n5\n1000000000\n",
"output": "3\n1\n0\n0\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/NBONACCI"
} | vfc_4706 |
apps | verifiable_code | 1467 | Solve the following coding problem using the programming language python:
Alice and Johnny are playing a simple guessing game. Johnny picks an arbitrary positive integer n (1<=n<=109) and gives Alice exactly k hints about the value of n. It is Alice's task to guess n, based on the received hints.
Alice often has a serious problem guessing the value of n, and she's beginning to suspect that Johnny occasionally cheats, that is, gives her incorrect hints.
After the last game, they had the following little conversation:
- [Alice] Johnny, you keep cheating!
- [Johnny] Indeed? You cannot prove it.
- [Alice] Oh yes I can. In fact, I can tell you with the utmost certainty that in the last game you lied to me at least *** times.
So, how many times at least did Johnny lie to Alice? Try to determine this, knowing only the hints Johnny gave to Alice.
-----Input-----
The first line of input contains t, the number of test cases (about 20). Exactly t test cases follow.
Each test case starts with a line containing a single integer k, denoting the number of hints given by Johnny (1<=k<=100000). Each of the next k lines contains exactly one hint. The i-th hint is of the form:
operator li logical_value
where operator denotes one of the symbols < , > , or =; li is an integer (1<=li<=109), while logical_value is one of the words: Yes or No. The hint is considered correct if logical_value is the correct reply to the question: "Does the relation: n operator li hold?", and is considered to be false (a lie) otherwise.
-----Output-----
For each test case output a line containing a single integer, equal to the minimal possible number of Johnny's lies during the game.
-----Example-----
Input:
3
2
< 100 No
> 100 No
3
< 2 Yes
> 4 Yes
= 3 No
6
< 2 Yes
> 1 Yes
= 1 Yes
= 1 Yes
> 1 Yes
= 1 Yes
Output:
0
1
2
Explanation: for the respective test cases, the number picked by Johnny could have been e.g. n=100, n=5, and n=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
def guessingGame (l):
a = []
m = 1000000001
for i in range (len(l)):
k=int(l[i][1])
if (l[i][0]=='<' and l[i][2]=='Yes'):
a.append((1,1))
a.append((k,-1))
if (l[i][0]=='<' and l[i][2]=='No'):
a.append((k,1))
a.append((m,-1))
if (l[i][0]=='=' and l[i][2]=='Yes'):
a.append((k,1))
a.append((k+1,-1))
if (l[i][0]=='=' and l[i][2]=='No'):
a.append((1,1))
a.append((k,-1))
a.append((k+1,1))
a.append((m,-1))
if (l[i][0]=='>' and l[i][2]=='Yes'):
a.append((k+1,1))
a.append((m,-1))
if (l[i][0]=='>' and l[i][2]=='No'):
a.append((1,1))
a.append((k+1,-1))
a.sort()
w=0
r=0
for i in range (len(a)):
w+=a[i][1]
r=max(w,r)
return len(l)-r
def __starting_point():
T = int(input())
answer = []
for _ in range (T):
e = int(input())
temp = []
for q_t in range (e):
q = list(map(str,input().rstrip().split()))
temp.append(q)
result = guessingGame(temp)
print(result)
__starting_point()
``` | {
"language": "python",
"test_cases": [
{
"input": "3\n2\n< 100 No\n> 100 No\n3\n< 2 Yes\n> 4 Yes\n= 3 No\n6\n< 2 Yes\n> 1 Yes\n= 1 Yes\n= 1 Yes\n> 1 Yes\n= 1 Yes\n",
"output": "0\n1\n2\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/A3"
} | vfc_4710 |
apps | verifiable_code | 1468 | 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)
``` | {
"language": "python",
"test_cases": [
{
"input": "3\nA\n1A23\n2C2A\n",
"output": "10\n6691\n11306\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/JLUG2020/problems/HXTDC"
} | vfc_4714 |
apps | verifiable_code | 1469 | Solve the following coding problem using the programming language python:
The chef is trying to decode some pattern problems, Chef wants your help to code it. Chef has one number K to form a new pattern. Help the chef to code this pattern problem.
-----Input:-----
- First-line will contain $T$, the number of test cases. Then the test cases follow.
- Each test case contains a single line of input, one integer $K$.
-----Output:-----
For each test case, output as the pattern.
-----Constraints-----
- $1 \leq T \leq 100$
- $1 \leq K \leq 100$
-----Sample Input:-----
4
1
2
3
4
-----Sample Output:-----
2
23
34
234
345
456
2345
3456
4567
5678
-----EXPLANATION:-----
No need, else pattern can be decode easily.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
try:
tc=int(input())
for _ in range(tc):
n=int(input())
st=""
b=1
for i in range(1,n+1):
b+=1
a=b
for j in range(1,n+1):
print(a,end='')
a+=1
print()
except:
pass
``` | {
"language": "python",
"test_cases": [
{
"input": "4\n1\n2\n3\n4\n",
"output": "2\n23\n34\n234\n345\n456\n2345\n3456\n4567\n5678\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/PTRN2021/problems/ITGUY53"
} | vfc_4718 |
apps | verifiable_code | 1470 | Solve the following coding problem using the programming language python:
Ahmed Gafer failed to pass the test, but he got the job because of his friendship with Said and Shahhoud. After working in the kitchen for a while, he blew it. The customers didn't like the food anymore and one day he even burned the kitchen. Now the master Chef is very upset.
Ahmed isn't useful anymore at being a co-Chef, so S&S decided to give him a last chance. They decided to give Ahmed a new job, and make him work as the cashier of the restaurant. Nevertheless, in order not to repeat their previous mistake, they decided to give him a little test to check if his counting skills are good enough for the job. The problem is as follows:
Given a string A of lowercase English letters, Ahmad was asked to find the number of good substrings.
A substring A[L, R] is good if:
- The length of the substring is exactly 2 and AL = AR, OR
- The length of the substring is greater than 2,AL = AR and the substring A[L + 1, R - 1] has only one distinct letter.
Anyways, Ahmed struggled trying to find a solution for the problem. Since his mathematical skills are very poor as it turned out, he decided to cheat and contacted you asking for your help. Can you help him in this challenge?
-----Input-----
The first line of the input contains the integer T, indicating the number of test cases.
Each of the following T lines, contains a string A.
-----Output-----
For each test case, output a single line containing a single number, indicating the number of good substrings.
-----Constraints-----
- 1 ≤ T ≤ 100
- 1 ≤ |A| ≤ 105
- It's guaranteed that the sum of |A| over all test cases doesn't exceed 5x105.
-----Example-----
Input:
2
a
abba
Output:
0
2
-----Explanation-----
Example case 2. The good substrings of abba are: { bb } and { abba }.
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())):
s=input()
count=0
i=0
while i<len(s)-1:
ch=s[i]
j=i+1
while j<len(s) and s[j]==ch:
j+=1
l=j-i
if i!=0 and j!=len(s) and s[i-1]==s[j] :
count+=1
count+=l*(l-1)//2
#print(s[i:j],count)
i=j
print(count)
``` | {
"language": "python",
"test_cases": [
{
"input": "2\na\nabba\n",
"output": "0\n2\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/CK87GSUB"
} | vfc_4722 |
apps | verifiable_code | 1472 | Solve the following coding problem using the programming language python:
$Neha$ is given a number $N$. She always looks for special thing , this time she is looking for $Special$ $Number$ and $Partial$ $Special$ $Number$. A $Special$ $Number$ is a number whose product of its digits is equal to number itself i.e. $N $, and in this number there is no digit $1$. $Partial$ $Special$ is a number having all the condition same as $Special$ except that it can also have digit $1$ in it .Neha have to count the number of $Special$ and $Partial$ $Special$ $Numbers $for a given $N$ . She is not so good in programming , so go and help her.
-----Input:-----
- Integers $N$ is taken as input from input stream.
-----Output:-----
- Print the number of $Special$ and $Partial$ $Special$ $Numbers $for a given $N$.
-----Constraints-----
- $1 \leq N \leq 100$ numbers to be count will be less then 10^6
-----Sample Input:-----
3
-----Sample Output:-----
1 20
-----EXPLANATION:-----
There are only one natural numbers, the product of the digits of which is 3 :- {3}.
There are 20 natural numbers with digit 1 , whose product of the digits is 3 :-{13, 31, 113 ,131 311 ,1113 ,1131 ,1311, 3111 ,11113, 11131, 11311 ,13111, 31111, 111113, 111131, 111311,113111, 131111 ,311111}
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
n=int(input())
a=[]
b=[]
for i in range(1,1000001):
s = str(i)
p=1
flag=0
for e in s:
if e=='1':
flag=1
p=p*int(e)
if p==n:
if flag!=1:
a.append(i)
else:
b.append(i)
print(len(a),len(b))
``` | {
"language": "python",
"test_cases": [
{
"input": "3\n",
"output": "1 20\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/CZEN2020/problems/NHSPN"
} | vfc_4730 |
apps | verifiable_code | 1473 | Solve the following coding problem using the programming language python:
Many things in this first paragraph are references to some pretty famous YouTube stars, so be careful about rephrasing. Thanks!
Michael, Kevin and Jake are sharing a cake, in celebration of their Webby award. They named it VCake. Unlike other cakes they considered, this one has finite volume and surface area. It's shaped as a normal rectangular cake with dimensions R centimeters by C centimeters. For the purposes of this problem, we can forget about three dimensions and think of a cake as just a 2D rectangle.
Chef will now cut the cake into three pieces, one for each person. However, the cake's shape and Chef's really old tools pose a few restrictions:
- Chef can only cut the cake, or a cake piece, across a line parallel to one of its sides.
- Chef can only cut the cake, or a cake piece, from end to end. That is, she cannot cut the cake partially.
- Chef can only cut the cake, or a cake piece, such that the sides of the resulting pieces (which will be rectangular in shape) are integers.
In addition, Michael, Kevin and Jake also have a few preferences of their own:
- They want their pieces to be connected (in one piece), and rectangular in shape.
- Michael wants his piece to have an area exactly M square centimeters. (Again, forget about a third dimension.)
- Kevin wants his piece to have an area exactly K square centimeters.
- Jake wants his piece to have an area exactly J square centimeters.
With these restrictions, Chef is at a loss. Is it possible for Chef to accomplish this task? Please note that the entire cake should be used. There should be no leftover cake.
-----Input-----
The first line of the input contains an integer T denoting the number of test cases. The description of T test cases follows.
Each test case consists of a single line containing five space separated integers R, C M, K and J.
-----Output-----
For each test case, output a single line containing either “Yes” or “No” (without quotes), denoting whether Chef can accomplish the task or not.
-----Constraints-----
- 1 ≤ T ≤ 105
- 1 ≤ R, C ≤ 109
- 1 ≤ M, K, J ≤ 1018
-----Example-----
Input:4
4 5 10 4 6
4 5 6 10 4
4 5 4 6 10
2 2 2 2 2
Output:Yes
Yes
Yes
No
-----Explanation-----
Example case 1. In this case, Chef can accomplish the task by doing the following slicing.
pre tt
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _________
| | | | | | |M M M M M|
| | -- |_ _ _ _ _| -- |_ _ _ _ _| -- |M_M_M_M_M|
| | | | | | | |J J J|K K|
|_ _ _ _ _| |_ _ _ _ _| |_ _ _|_ _| |J_J_J|K_K|
/tt /pre
I'll make an image if I have time
Example case 4. Here, Michael, Kevin and Jake each wants a piece with area 2, but the total area of the cake is only 2×2 = 4. This means the task is impossible.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
#!/usr/bin/python
import sys
def __starting_point():
t = int(input())
for iteration in range(t):
r,c,m_inp,k_inp,j_inp = input().strip().split(" ")
r=int(r)
c=int(c)
m_inp=int(m_inp)
k_inp=int(k_inp)
j_inp=int(j_inp)
ans = ""
if (r*c) != (m_inp+k_inp+j_inp):
print("No")
continue
else:
flag = False
for i in range(6):
if flag:
break
if i==0:
m = m_inp
k = k_inp
j = j_inp
elif i==1:
m = j_inp
k = m_inp
j = k_inp
elif i==2:
m = k_inp
k = j_inp
j = m_inp
elif i==3:
m = m_inp
k = j_inp
j = k_inp
elif i==4:
m = k_inp
k = m_inp
j = j_inp
elif i==5:
m = j_inp
k = k_inp
j = m_inp
if m%r == 0:
r_remain_1 = r
c_remain_1 = c-(m/r)
if k%r_remain_1 == 0:
r_remain_2 = r_remain_1
c_remain_2 = c_remain_1 - (k/r_remain_1)
if r_remain_2*c_remain_2 == j:
print("Yes")
flag = True
continue
if k%c_remain_1 == 0:
c_remain_2 = c_remain_1
r_remain_2 = r_remain_1 - (k/c_remain_1)
if r_remain_2*c_remain_2 == j:
print("Yes")
flag = True
continue
if j%r_remain_1 == 0:
r_remain_2 = r_remain_1
c_remain_2 = c_remain_1 - (j/r_remain_1)
if r_remain_2*c_remain_2 == k:
print("Yes")
flag = True
continue
if j%c_remain_1 == 0:
c_remain_2 = c_remain_1
r_remain_2 = r_remain_1 - (j/c_remain_1)
if r_remain_2*c_remain_2 == k:
print("Yes")
flag = True
continue
if m%c == 0:
c_remain_1 = c
r_remain_1 = r-(m/c)
if k%r_remain_1 == 0:
r_remain_2 = r_remain_1
c_remain_2 = c_remain_1 - (k/r_remain_1)
if r_remain_2*c_remain_2 == j:
print("Yes")
flag = True
continue
if k%c_remain_1 == 0:
c_remain_2 = c_remain_1
r_remain_2 = r_remain_1 - (k/c_remain_1)
if r_remain_2*c_remain_2 == j:
print("Yes")
flag = True
continue
if j%r_remain_1 == 0:
r_remain_2 = r_remain_1
c_remain_2 = c_remain_1 - (j/r_remain_1)
if r_remain_2*c_remain_2 == k:
print("Yes")
flag = True
continue
if j%c_remain_1 == 0:
c_remain_2 = c_remain_1
r_remain_2 = r_remain_1 - (j/c_remain_1)
if r_remain_2*c_remain_2 == k:
print("Yes")
flag = True
continue
if not flag:
print("No")
__starting_point()
``` | {
"language": "python",
"test_cases": [
{
"input": "4\n4 5 10 4 6\n4 5 6 10 4\n4 5 4 6 10\n2 2 2 2 2\n",
"output": "Yes\nYes\nYes\nNo\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/SNCKEL16/problems/VCAKE"
} | vfc_4734 |
apps | verifiable_code | 1474 | Solve the following coding problem using the programming language python:
Stuart is obsessed to numbers. He like all type of numbers in fact he is having a great collection of numbers in his room. His collection includes N different large numbers. But today he is searching for a number which is having maximum frequency of digit X. Numbers are large so he can’t do the task on his own. Help him to find a number having maximum frequency of digit X.
-----Input-----
First Line contains number of test cases T. First Line of each test case contains N. Next line contains N space separated integers A1,A2,A3,....,AN. Where Ai integer indicates ith number in Stuart's room. Next Line contains digit X.
-----Output-----
Output the number which is having maximum frequency of digit X. If two or more numbers are having same maximum frequency then output the first occurred number among them in A1,A2,A3,....,AN
-----Constraints-----
- 1 ≤ T ≤ 30
- 1 ≤ N ≤ 100
- 1 ≤ Ai ≤ 10200
- 0 ≤ X ≤ 9
-----Example-----
Input:
2
5
345 1323 165 98 456
3
5
335 876 98 1323 349
3
Output:
1323
335
-----Explanation-----
Example case 1. 1323 number is having maximum occurrence of digit 3.
Example case 2. 335 & 1323 are having maximum occurrence of digit 3 so output must be first occurred number in the array i.e. 335.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
T = int(input())
def call_me(N,A,X):
max = 0
ans = ''
for i in A:
if i.count(X) > max:
max = i.count(X)
ans = i
return ans
for i in range(T):
N = int(input())
A = list(map(str,input().split()))
X = input()
print(call_me(N,A,X))
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n5\n345 1323 165 98 456\n3\n5\n335 876 98 1323 349\n3\n",
"output": "1323\n335\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/CFSN2015/problems/LINNUM"
} | vfc_4738 |
apps | verifiable_code | 1475 | Solve the following coding problem using the programming language python:
Abhiram needs to search for an antidote. He comes to know that clue for finding the antidote is carefully hidden by KrishnaMurthy in the form of a puzzle.
The puzzle consists of a string S and a keywordK. Abhiram needs to find the string of position of anagrams R of the keyword in the string which is the clue.
The antidote is found in the box numbered R. Help him find his clue R.
Anagram: A word or phrase that is made by arranging the letters of another word or phrase in a different order. Eg: 'elvis' and 'lives' are both anagrams of each other.
Note: Consider, Tac and act are not anagrams(case sensitive).
-----Input:-----
The first line contains a string S of length land the second line contains a keyword K.
-----Output:-----
Output contains a line"The antidote is found in R." Where R= string of positions of anagrams.(the position of the first word in the string is 1).
-----Constraints:-----
1<=l<=500
1<=k<=50
-----Example:-----
Input:
cat is the act of tac
cat
Output:
The antidote is found in 46.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
x = input().split(" ")
y = input()
ans = ''
l = 1
for i in x:
if i!=y and sorted(i) == sorted(y):
ans = ans + (str)(l)
l=l+1
ans+='.'
print("The antidote is found in",ans)
``` | {
"language": "python",
"test_cases": [
{
"input": "cat is the act of tac\ncat\n",
"output": "The antidote is found in 46.\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/ITRA2016/problems/ITRA10"
} | vfc_4742 |
apps | verifiable_code | 1476 | Solve the following coding problem using the programming language python:
Chef has decided to retire and settle near a peaceful beach. He had always been interested in literature & linguistics. Now when he has leisure time, he plans to read a lot of novels and understand structure of languages. Today he has decided to learn a difficult language called Smeagolese. Smeagolese is an exotic language whose alphabet is lowercase and uppercase roman letters. Also every word on this alphabet is a meaningful word in Smeagolese. Chef, we all know is a fierce learner - he has given himself a tough exercise. He has taken a word and wants to determine all possible anagrams of the word which mean something in Smeagolese. Can you help him ?
-----Input-----
Input begins with a single integer T, denoting the number of test cases. After that T lines follow each containing a single string S - the word chef has chosen. You can assume that 1 <= T <= 500 and 1 <= |S| <= 500. You can also assume that no character repeats more than 10 times in the string.
-----Output-----
Output one line per test case - the number of different words that are anagrams of the word that chef has chosen. As answer can get huge, print it modulo 10^9 + 7
-----Example-----
Input:
4
ab
aa
aA
AAbaz
Output:
2
1
2
60
Description:
In first case "ab" & "ba" are two different words. In third case, note that A & a are different alphabets and hence "Aa" & "aA" are different words.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
# cook your dish here
from collections import Counter
from math import factorial
for _ in range(int(input())):
s=input()
c=Counter(s)
k=factorial(len(s))
for value in c.values():
if value>1:
k=k//factorial(value)
print(k%(10**9+7))
``` | {
"language": "python",
"test_cases": [
{
"input": "4\nab\naa\naA\nAAbaz\n",
"output": "2\n1\n2\n60\nDescription:\nIn first case \"ab\" & \"ba\" are two different words. In third case, note that A & a are different alphabets and hence \"Aa\" & \"aA\" are different words.\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/WCOUNT"
} | vfc_4746 |
apps | verifiable_code | 1477 | Solve the following coding problem using the programming language python:
You have a string S consisting of N uppercase English letters. You are allowed to perform at most one operation of following kind: Choose any position in the string, remove the character at that position and insert it back to any other place in the string.
Find the lexicographically smallest string you can achieve.
-----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 the single integer N denoting length of string S.
The second line contains the string S.
-----Output-----
For each test case, output a single line containing the answer to the corresponding test case.
-----Constraints-----
- 1 ≤ T ≤ 50
- 1 ≤ N ≤ 50
- S will consist of uppercase English letters.
-----Example-----
Input:
2
4
DCBA
7
XYZZYZZ
Output:
ADCB
XYYZZZZ
-----Explanation-----
Example case 1. The optimal solution here is to choose the last character and put it in the beginning of the string. So the answer will be ADCB
Example case 2. The optimal solution here is to choose the 5-th character (1-based index) and put it between the 2-nd and the 3-rd characters. So the answer will be XYYZZZZ
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
for _1 in range(int(input())):
n=int(input())
s=input().strip()
answer=s
for i in range(len(s)):
c=s[i]
string=s[:i]+s[i+1:]
for j in range(len(string)+1):
answer=min(answer, string[:j]+c+string[j:])
print(answer)
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n4\nDCBA\n7\nXYZZYZZ\n",
"output": "ADCB\nXYYZZZZ\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/DIVGOLD"
} | vfc_4750 |
apps | verifiable_code | 1478 | Solve the following coding problem using the programming language python:
Let's define a periodic infinite sequence S$S$ (0$0$-indexed) with period K$K$ using the formula Si=(i%K)+1$S_i = (i \% K) + 1$.
Chef has found a sequence of positive integers A$A$ with length N$N$ buried underground. He suspects that it is a contiguous subsequence of some periodic sequence. Unfortunately, some elements of A$A$ are unreadable. Can you tell Chef the longest possible period K$K$ of an infinite periodic sequence which contains A$A$ (after suitably filling in the unreadable elements) as a contiguous subsequence?
-----Input-----
- The first line of the input contains a single integer T$T$ denoting the number of test cases. The description of T$T$ test cases follows.
- The first line of each test case contains a single integer N$N$.
- The second line contains N$N$ space-separated integers A1,A2,…,AN$A_1, A_2, \dots, A_N$. Unreadable elements are denoted by −1$-1$.
-----Output-----
For each test case, print a single line.
- If the period can be arbitrarily large, this line should contain a single string "inf".
- Otherwise, if A$A$ cannot be a contiguous subsequence of a periodic sequence, it should contain a single string "impossible".
- Otherwise, it should contain a single integer — the maximum possible period.
-----Constraints-----
- 1≤T≤100$1 \le T \le 100$
- 2≤N≤105$2 \le N \le 10^5$
- the sum of N$N$ over all test cases does not exceed 106$10^6$
- for each valid i$i$, 1≤Ai≤106$1 \le A_i \le 10^6$ or Ai=−1$A_i = -1$
-----Subtasks-----
Subtask #1 (50 points):
- 2≤N≤1,000$2 \le N \le 1,000$
- the sum of N$N$ over all test cases does not exceed 10,000$10,000$
Subtask #2 (50 points): original constraints
-----Example Input-----
3
3
-1 -1 -1
5
1 -1 -1 4 1
4
4 6 7 -1
-----Example Output-----
inf
4
impossible
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 math import gcd
for _ in range(int(input())):
n,a,k,min_k,e = int(input()),[int(i) for i in input().split()],0,0,-1
for j in range(n):
if(a[j] != -1):break
for i in range(j,n):
if min_k==0:min_k,e = a[i],a[i]+1
else:
if min_k < a[i]:min_k = a[i]
if(a[i] == -1):pass
else:
if(a[i] == e):pass
else:
if( k == 0):k = e-a[i]
else:
new_k = e-a[i]
if(new_k < 0):k = -1
else:k = gcd(k,new_k)
if(k<min_k or k<0): k = -1; break
if k != 0 and a[i]!=-1: e = a[i]%k+1
else:e += 1
if(k == -1):print("impossible")
elif k == 0 :print("inf")
else:print(k)
``` | {
"language": "python",
"test_cases": [
{
"input": "3\n3\n-1 -1 -1\n5\n1 -1 -1 4 1\n4\n4 6 7 -1\n",
"output": "inf\n4\nimpossible\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/PERIODIC"
} | vfc_4754 |
apps | verifiable_code | 1479 | Solve the following coding problem using the programming language python:
You are participating in a contest which has $11$ problems (numbered $1$ through $11$). The first eight problems (i.e. problems $1, 2, \ldots, 8$) are scorable, while the last three problems ($9$, $10$ and $11$) are non-scorable ― this means that any submissions you make on any of these problems do not affect your total score.
Your total score is the sum of your best scores for all scorable problems. That is, for each scorable problem, you look at the scores of all submissions you made on that problem and take the maximum of these scores (or $0$ if you didn't make any submissions on that problem); the total score is the sum of the maximum scores you took.
You know the results of all submissions you made. Calculate your total score.
-----Input-----
- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
- The first line of each test case contains a single integer $N$ denoting the number of submissions you made.
- $N$ lines follow. For each $i$ ($1 \le i \le N$), the $i$-th of these lines contains two space-separated integers $p_i$ and $s_i$, denoting that your $i$-th submission was on problem $p_i$ and it received a score $s_i$.
-----Output-----
For each test case, print a single line containing one integer ― your total score.
-----Constraints-----
- $1 \le T \le 10$
- $1 \le N \le 1,000$
- $1 \le p_i \le 11$ for each valid $i$
- $0 \le s_i \le 100$ for each valid $i$
-----Subtasks-----
Subtask #1 (15 points): all submissions are on the same problem, i.e. $p_1 = p_2 = \ldots = p_N$
Subtask #2 (15 points): there is at most one submission made on each problem, i.e. $p_i \neq p_j$ for each valid $i, j$ ($i \neq j$)
Subtask #3 (70 points): original constraints
-----Example Input-----
2
5
2 45
9 100
8 0
2 15
8 90
1
11 1
-----Example Output-----
135
0
-----Explanation-----
Example case 1: The scorable problems with at least one submission are problems $2$ and $8$. For problem $2$, there are two submissions and the maximum score among them is $45$. For problem $8$, there are also two submissions and the maximum score is $90$. Hence, the total score is $45 + 90 = 135$.
Example case 2: No scorable problem is attempted, so the total score is $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
p=int(input())
for z in range(p):
n=int(input())
a=[]
for i in range(8):
a.append(0)
for i in range(n):
x,y=list(map(int,input().split()))
if x<=8 and y>a[x-1]:
a[x-1]=y
print(sum(a))
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n5\n2 45\n9 100\n8 0\n2 15\n8 90\n1\n11 1\n",
"output": "135\n0\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/WATSCORE"
} | vfc_4758 |
apps | verifiable_code | 1480 | Solve the following coding problem using the programming language python:
There are n cabs in a city numbered from 1 to n. The city has a rule that only one cab can run in the city at a time. Cab picks up the customer and drops him to his destination. Then the cab gets ready to pick next customer. There are m customers in search of cab. First customer will get the taxi first. You have to find the nearest cab for each customer. If two cabs have same distance then the cab with lower number is preferred.
Your task is to find out minimum distant cab for each customer.
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 two space-separated integers N and M, denoting the number of cabs and the number of customers.
The next N lines contain two space-separated integers x[i] and y[i], denoting the initial position of the ith cab.
Next line contains an integer M denoting number of customers.
The next M lines contain four space seperated integers sx[i], sy[i], dx[i], dy[i], denoting the current location and the destination of the ith customer.
Output:
Output the nearest cab number for each customer.
Constraints:
1<=t<=10
1<=n,m<=1000
-10^9<=x[i] , y[i] , sx[i] , sy[i] , dx[i] , dy[i]<=10^9
Example:
Input:
1
3 2
1 3
3 2
3 5
2 3 3 4
5 3 4 1
Output:
1
1
Explanation:
The distance of cab1 from customer1 = sqrt((1-2)^2 + (3-3)^2) = 1
The distance of cab2 from customer1 = sqrt(2)
The distance of cab3 from customer1 = sqrt(5)
So output for customer1 is 1
Now location of cab1 is (3,4)
The distance of cab1 from customer2 = sqrt((3-5)^2 + (4-3)^2) = sqrt(5)
The distance of cab2 from customer2 = sqrt(5)
The distance of cab3 from customer2 = sqrt(8)
So output for customer2 is 1
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 dist(w,x,y,z):
return math.hypot(y - w, z - x)
t = int(input())
while (t>0):
t = t -1
n, m = list(map(int,input().split()))
a = []
for i in range(0,n):
x,y = list(map(int,input().split()))
a.append([x,y])
for j in range(0,m):
p,q,r,s = list(map(int,input().split()))
nearest = -1
distance = 10000000000
for i in range(0,n):
way = dist(a[i][0],a[i][1],p,q)
if way < distance:
distance = way
nearest = i
print(nearest + 1)
a[nearest][0] = r
a[nearest][1] = s
``` | {
"language": "python",
"test_cases": [
{
"input": "1\n3 2\n1 3\n3 2\n3 5\n2 3 3 4\n5 3 4 1\n",
"output": "1\n1\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/SIC2016/problems/NEAR"
} | vfc_4762 |
apps | verifiable_code | 1482 | Solve the following coding problem using the programming language python:
Chef's company wants to make ATM PINs for its users, so that they could use the PINs for withdrawing their hard-earned money. One of these users is Reziba, who lives in an area where a lot of robberies take place when people try to withdraw their money.
Chef plans to include a safety feature in the PINs: if someone inputs the reverse of their own PIN in an ATM machine, the Crime Investigation Department (CID) are immediately informed and stop the robbery. However, even though this was implemented by Chef, some people could still continue to get robbed. The reason is that CID is only informed if the reverse of a PIN is different from that PIN (so that there wouldn't be false reports of robberies).
You know that a PIN consists of $N$ decimal digits. Find the probability that Reziba could get robbed. Specifically, it can be proven that this probability can be written as a fraction $P/Q$, where $P \ge 0$ and $Q > 0$ are coprime integers; you should compute $P$ and $Q$.
-----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$ denoting the length of each PIN.
-----Output-----
For each test case, print a single line containing two space-separated integers — the numerator $P$ and denominator $Q$ of the probability.
-----Constraints-----
- $1 \le T \le 100$
- $1 \le N \le 10^5$
-----Subtasks-----
Subtask #1 (10 points): $N \le 18$
Subtask #2 (20 points): $N \le 36$
Subtask #3 (70 points): original constraints
-----Example Input-----
1
1
-----Example Output-----
1 1
-----Explanation-----
Example case 1: A PIN containing only one number would fail to inform the CID, since when it's input in reverse, the ATM detects the same PIN as the correct one. Therefore, Reziba can always get robbed — the probability is $1 = 1/1$.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
for i in range(int(input())):
n = int(input())
q = "1"+"0"*(n//2)
print(1,q)
``` | {
"language": "python",
"test_cases": [
{
"input": "1\n1\n",
"output": "1 1\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/PINS"
} | vfc_4770 |
apps | verifiable_code | 1483 | Solve the following coding problem using the programming language python:
As we all know caterpillars love to eat leaves. Usually, a caterpillar sits on leaf, eats as much of it as it can (or wants), then stretches out to its full length to reach a new leaf with its front end, and finally "hops" to it by contracting its back end to that leaf.
We have with us a very long, straight branch of a tree with leaves distributed uniformly along its length, and a set of caterpillars sitting on the first leaf. (Well, our leaves are big enough to accommodate upto $20$ caterpillars!). As time progresses our caterpillars eat and hop repeatedly, thereby damaging many leaves. Not all caterpillars are of the same length, so different caterpillars may eat different sets of leaves. We would like to find out the number of leaves that will be undamaged at the end of this eating spree. We assume that adjacent leaves are a unit distance apart and the length of the caterpillars is also given in the same unit.
For example suppose our branch had $20$ leaves (placed $1$ unit apart) and $3$ caterpillars of length $3, 2$ and $5$ units respectively. Then, first caterpillar would first eat leaf $1$, then hop to leaf $4$ and eat it and then hop to leaf $7$ and eat it and so on. So the first caterpillar would end up eating the leaves at positions $1,4,7,10,13,16$ and $19$. The second caterpillar would eat the leaves at positions $1,3,5,7,9,11,13,15,17$ and $19$. The third caterpillar would eat the leaves at positions $1,6,11$ and $16$. Thus we would have undamaged leaves at positions $2,8,12,14,18$ and $20$. So the answer to this example is $6$.
-----Input:-----
The first line of the input contains two integers $N$ and $K$, where $N$ is the number of leaves and $K$ is the number of caterpillars. Lines $2,3,...,K+1$ describe the lengths of the $K$ caterpillars. Line $i+1$ ($1 \leq i \leq K$) contains a single integer representing the length of the $i^{th}$ caterpillar.
-----Output:-----
A line containing a single integer, which is the number of leaves left on the branch after all the caterpillars have finished their eating spree.
-----Constraints:-----
- $1 \leq N \leq 1000000000$.
- $1 \leq K \leq 20$.
- The length of the caterpillars lie between $1$ and $N$.
- $50 \%$ of test cases will also satisfy $1 \leq N \leq 10000000$ and $1 \leq K \leq 16$.
-----Sample Input:-----
20 3
3
2
5
-----Sample Output:-----
6
-----Hint:-----
You may use $64$-bit integers (long long in C/C++) to avoid errors while multiplying large integers. The maximum value you can store in a $32$-bit integer is $2^{31}-1$, which is approximately $2 \cdot 10^9$. $64$-bit integers can store values greater than $10^{18}$.
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 gcd
n, k = list(map(int, input().split()))
a = []
for i in range(k):
try:
a += list(map(int, input().split()))
except:
pass
ans = n
for i in range(1, 2**k):
b = bin(i)[2:].rjust(k, "0")
c = []
for j in range(k):
if(b[j] == '1'):
c.append(a[j])
lcm = c[0]
for j in c[1:]:
lcm *= j // gcd(lcm, j)
temp = ((n - 1) // lcm) + 1
if(b.count('1')&1):
ans -= temp
else:
ans += temp
print(ans)
``` | {
"language": "python",
"test_cases": [
{
"input": "20 3\n3\n2\n5\n",
"output": "6\nHint:\nYou may use 64 -bit integers ( long long in C/C++) to avoid errors while multiplying large integers. The maximum value you can store in a 32 -bit integer is 2 31 − 1 , which is approximately 2 ⋅ 10 9 . 64 -bit integers can store values greater than 10 18 .\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/IARCSJUD/problems/LEAFEAT"
} | vfc_4774 |
Subsets and Splits