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
| contaminated_aime_2024
bool 1
class | contaminated_aime_2025
bool 1
class | contaminated_math_500
bool 1
class | contaminated_gpqa
bool 1
class | contaminated_lcb
bool 2
classes |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
apps | verifiable_code | 1086 | Solve the following coding problem using the programming language python:
Let's define the niceness of a sequence of positive integers X1,X2,…,XN$X_1, X_2, \dots, X_N$ as the sum of greatest common divisors of all pairs of its elements, i.e.
N∑i=1N∑j=i+1gcd(Xi,Xj).∑i=1N∑j=i+1Ngcd(Xi,Xj).\sum_{i=1}^N \sum_{j=i+1}^N \mathrm{gcd}(X_i, X_j)\;.
For example, the niceness of the sequence [1,2,2]$[1, 2, 2]$ is gcd(1,2)+gcd(1,2)+gcd(2,2)=4$gcd(1, 2) + gcd(1, 2) + gcd(2, 2) = 4$.
You are given a sequence A1,A2,…,AN$A_1, A_2, \dots, A_N$; each of its elements is either a positive integer or missing.
Consider all possible ways to replace each missing element of A$A$ by a positive integer (not necessarily the same for each element) such that the sum of all elements is equal to S$S$. Your task is to find the total niceness of all resulting sequences, i.e. compute the niceness of each possible resulting sequence and sum up all these values. Since the answer may be very large, compute it modulo 109+7$10^9 + 7$.
-----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 S$S$.
- The second line contains N$N$ space-separated integers A1,A2,…,AN$A_1, A_2, \dots, A_N$. Missing elements in this sequence are denoted by −1$-1$.
-----Output-----
For each test case, print a single line containing one integer — the total niceness modulo 109+7$10^9 + 7$.
-----Constraints-----
- 1≤T≤20$1 \le T \le 20$
- 1≤N,S≤50$1 \le N, S \le 50$
- 1≤Ai≤50$1 \le A_i \le 50$ or Ai=−1$A_i = -1$ for each valid i$i$
-----Subtasks-----
Subtask #1 (30 points):
- 1≤N,S≤18$1 \le N, S \le 18$
- 1≤Ai≤18$1 \le A_i \le 18$ or Ai=−1$A_i = -1$ for each valid i$i$
Subtask #2 (70 points): original constraints
-----Example Input-----
3
3 3
1 1 -1
4 8
1 -1 -1 3
3 10
-1 -1 -1
-----Example Output-----
3
23
150
-----Explanation-----
Example case 1: There is only one possible way to fill in the missing element; the resulting sequence is [1,1,1]$[1, 1, 1]$. Its niceness is 3$3$.
Example case 2: There is only three possible ways to fill in the missing elements; the resulting sequences are [1,1,3,3]$[1, 1, 3, 3]$, [1,3,1,3]$[1, 3, 1, 3]$, and [1,2,2,3]$[1, 2, 2, 3]$. The sum of their niceness is 8+8+7=23$8 + 8 + 7 = 23$.
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
mod = 10**9 + 7
from math import gcd
def fac50():
f = [0]*51
f[0] ,f[1] = 1,1
for i in range(1,51):f[i] = (f[i-1]*i)%mod
return f
def gcd110():
gc = [[0]*111 for i in range(111)]
for i in range(111):
for j in range(111):gc[i][j] = gcd(i,j)
return gc
factorials,gcds = fac50(),gcd110()
def rule_asc(n,l):
a,k = [0 for i in range(n + 1)],1
a[1] = n
while k != 0:
x,y = a[k - 1] + 1,a[k] - 1
k -= 1
while x <= y and k < l - 1:
a[k],y = x,y-x
k += 1
a[k] = x + y
yield a[:k + 1]
def niceness(s):
t = 0
for i in range(len(s)):
for j in range(i+1,len(s)):t = (t + gcds[s[i]][s[j]])%mod
return t
def permcount(s,c):
f,p = [s.count(x) for x in set(s)],factorials[c]
for e in f:p = (p*pow(factorials[e],mod-2,mod))%mod
return p
def main():
for i in range(int(input())):
n,s = [int(item) for item in input().split()]
a = [int(item) for item in input().split()]
b = [i for i in a if i != -1]
s , ones = s - sum(b),a.count(-1)
if s < 0:print(0)
elif (s == 0 and ones == 0):print(niceness(a)%mod)
elif (s > 0 and ones == 0):print(0)
else:
t = 0
for seq in rule_asc(s,ones):
if len(seq) == ones: t = (t + (((permcount(seq,ones))%mod)*(niceness(b+seq)%mod))%mod)%mod
print(t)
def __starting_point():main()
__starting_point()
``` | {
"language": "python",
"test_cases": [
{
"input": "3\n3 3\n1 1 -1\n4 8\n1 -1 -1 3\n3 10\n-1 -1 -1\n\n",
"output": "3\n23\n150\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/NICARRAY"
} | vfc_3186 | false | false | false | false | false |
apps | verifiable_code | 1087 | Solve the following coding problem using the programming language python:
You are given an unweighted, undirected graph. Write a program to check if it's a tree topology.
-----Input-----
The first line of the input file contains two integers N and M --- number of nodes and number of edges in the graph (0 < N <= 10000, 0 <= M <= 20000). Next M lines contain M edges of that graph --- Each line contains a pair (u, v) means there is an edge between node u and node v (1 <= u,v <= N).
-----Output-----
Print YES if the given graph is a tree, otherwise print NO.
-----Example-----
Input:
3 2
1 2
2 3
Output:
YES
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
#!/usr/bin/env python
def iscycle(E, v, EXPLORED_NODES, EXPLORED_EDGES):
EXPLORED_NODES.add(v)
r = False
for e in [x for x in E if v in x]:
if e in EXPLORED_EDGES: continue
if e[0] == v: w = e[1]
else: w = e[0]
if w in EXPLORED_NODES:
return True
else:
EXPLORED_EDGES.add(e)
r = r or iscycle(E, w, EXPLORED_NODES, EXPLORED_EDGES)
if r: break
return r
def process(E):
return iscycle(E, 1, set(), set()) and 'NO' or 'YES'
def main():
N, M = list(map(int, input().split()))
E = []
for m in range(M):
U, V = list(map(int, input().split()))
if U > V: U, V = V, U
E.append((U, V))
print(process(E))
main()
``` | {
"language": "python",
"test_cases": [
{
"input": "3 2\n1 2\n2 3\n",
"output": "YES\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/PRFT2012/problems/PD31"
} | vfc_3190 | false | false | false | false | false |
apps | verifiable_code | 1088 | Solve the following coding problem using the programming language python:
Two cheeky thieves (Chef being one of them, the more talented one of course) have came across each other in the underground vault of the State Bank of Churuland. They are shocked! Indeed, neither expect to meet a colleague in such a place with the same intentions to carry away all the money collected during Churufest 2015.
They have carefully counted a total of exactly 1 billion (109) dollars in the bank vault. Now they must decide how to divide the booty. But there is one problem: the thieves have only M minutes to leave the bank before the police arrives. Also, the more time they spend in the vault, the less amount could carry away from the bank. Formally speaking, they can get away with all of the billion dollars right now, but after t minutes they can carry away only 1 billion * pt dollars, where p is some non-negative constant less than or equal to unity, and at t = M, they get arrested and lose all the money.
They will not leave the vault until a decision on how to divide the money has been made.
The money division process proceeds in the following way: at the beginning of each minute starting from the 1st (that is, t = 0), one of them proposes his own way to divide the booty. If his colleague agrees, they leave the bank with pockets filled with the proposed amounts of dollars. If not, the other one proposes his way at the next minute etc. To escape arrest, they can only propose plans till the beginning of the Mth minute (i.e., till t = M-1).
Each thief wants to maximize his earnings, but if there are two plans with the same amounts for him, he would choose the one which leads to a larger total amount of stolen dollars.
Chef is about to start this procedure, and he is the first to propose a plan. You are wondering what will be the final division of money, if each thief chooses the optimal way for himself and money is considering real.
-----Input-----
The first line of input contains an integer T denoting the number of test cases. The description of T test cases follows. The only line of input for each test case contains an integer M denoting the number of minutes until arrest and a double denoting the constant p.
-----Output-----
For each test case, output a single line containing two space-separated doubles denoting the amount of dollars each thief will get in the optimal division. First number: dollars amassed by Chef, and second: by his colleague. The answer will be considered correct if its absolute error doesn't exceed 10-2.
-----Constraints and subtasks-----
- 1 ≤ T ≤ 105
- 0 ≤ p ≤ 1
Subtask 1 (15 points) :
1 ≤ M ≤ 3
Subtask 2 (55 points) :
1 ≤ M ≤ 103
Subtask 3 (30 points) :
1 ≤ M ≤ 109
-----Example-----
Input:
2
1 0.5
2 0.5
Output:
1000000000.0 0.0
500000000.0 500000000.0
-----Explanation-----
Example case 1. In the second case, if decision isn't made at t = 0, total amount of money decreases to 5*108 at t = 1 which leads to a situation worse than the given solution.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
t=int(input())
while(t):
s=input().split()
m=int(s[0])
p=float(s[1])
if(m%2==0):
r=(1-p**m)/(p+1)
else:
r=(1+p**m)/(p+1)
print(1000000000*r,1000000000*(1-r))
t-=1
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n1 0.5\n2 0.5\n",
"output": "1000000000.0 0.0\n500000000.0 500000000.0\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/BANROB"
} | vfc_3194 | false | false | false | false | false |
apps | verifiable_code | 1089 | Solve the following coding problem using the programming language python:
The garden has a tree with too many leaves on it and gardner wants to cut the unwanted leaves. This is a rooted tree, where a node $v$ is called parent of another node $u$, if there exists a directed edge from $v$ to $u$. Leaf node is a node with no outgoing edges.
Gardner cuts the tree in a peculiar way:
- For each parent node(which has a valid leaf node attached to it), he cuts $x$ leaf nodes, such that $x$ is a multiple of 3.
Example : If a parent node has 7 leaf nodes, 6 leaf nodes will be cut and 1 will be left.
- If a parent has all its leaf nodes cut, only then the parent node itself becomes a new leaf node. If new leaf nodes are created, Gardner repeats step 1 until he can cut no more leaf nodes.
After completing all operations, gardner wants to know the minimum number of nodes left on the tree.
It is guaranteed that the given input is a rooted tree.
The root of the tree is vertex 1.
-----Input:-----
- First line will contain $T$, number of testcases. Then the testcases follow.
- First line of each testcase contains an integer $n$, the number of vertices in the tree.
- Second line of each testcase contains array $A$ of size $n-1$, where $A_{i}(1≤i≤n-1)$, is the index of the parent of the $(i+1)^{th}$ vertex.
-----Output:-----
For each testcase, output single integer, the number of nodes finally left on the tree.
-----Constraints-----
- $1 \leq T \leq 10$
- $2 \leq n \leq 10^5$
- $1 \leq A_i \leq i$
-----Sample Input:-----
1
13
1 1 1 1 1 4 3 4 4 3 4 3
-----Sample Output:-----
4
-----EXPLANATION:-----
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
def dfs(node):
nonlocal adj,leaf
val=0
flag=0
for i in adj[node]:
x= dfs(i)
val+=x
if x==0:
flag=1
leaf+=val-val%3
if val%3==0 and flag==0:
return 1
else:
return 0
for _ in range(int(input())):
n=int(input())
adj=[[] for i in range(n+2)]
arr=[int(i) for i in input().split()]
leaf=0
#print(adj)
for i in range(2,n+1):
#print(i,arr[i-2])
adj[arr[i-2]].append(i)
dfs(1)
print(n-leaf)
``` | {
"language": "python",
"test_cases": [
{
"input": "1\n13\n1 1 1 1 1 4 3 4 4 3 4 3\n",
"output": "4\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/ECPG2020/problems/ECPC10D"
} | vfc_3198 | false | false | false | false | false |
apps | verifiable_code | 1090 | Solve the following coding problem using the programming language python:
You are given a sequence of n integers a1, a2, ..., an and an integer d.
Find the length of the shortest non-empty contiguous subsequence with sum of elements at least d. Formally, you should find the smallest positive integer k with the following property: there is an integer s (1 ≤ s ≤ N-k+1) such that as + as+1 + ... + as+k-1 ≥ d.
-----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 d.
- The second line contains n space-separated integers a1, a2, ..., an.
-----Output-----
For each test case, print a single line containing one integer — the length of the shortest contiguous subsequence with sum of elements ≥ d. If there is no such subsequence, print -1 instead.
-----Constraints-----
- 1 ≤ T ≤ 105
- 1 ≤ n ≤ 105
- -109 ≤ d ≤ 109
- -104 ≤ ai ≤ 104
- 1 ≤ sum of n over all test cases ≤ 2 · 105
-----Example-----
Input:
2
5 5
1 2 3 1 -5
5 1
1 2 3 1 -5
Output:
2
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
import collections
def shortestSubarray(A, K):
N = len(A)
P = [0]
for x in A:
P.append(P[-1] + x)
#Want smallest y-x with Py - Px >= K
ans = N+1 # N+1 is impossible
monoq = collections.deque() #opt(y) candidates, represented as indices of P
for y, Py in enumerate(P):
#Want opt(y) = largest x with Px <= Py - K
if not monoq:
if Py>=K: return 1
while monoq and Py <= P[monoq[-1]]:
monoq.pop()
while monoq and Py - P[monoq[0]] >= K:
ans = min(ans, y - monoq.popleft())
monoq.append(y)
return ans if ans < N+1 else -1
for t in range(int(input())):
N, D = [int(x) for x in input().split()]
A = [int(x) for x in input().split()]
print(shortestSubarray(A, D))
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n5 5\n1 2 3 1 -5\n5 1\n1 2 3 1 -5\n",
"output": "2\n1\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/MINSUBAR"
} | vfc_3202 | false | false | false | false | false |
apps | verifiable_code | 1091 | Solve the following coding problem using the programming language python:
Rupsa really loves triangles. One day she came across an equilateral triangle having length of each side as an integer N. She started wondering if it was possible to transform the triangle keeping two sides fixed and alter the third side such that it still remains a triangle, but the altered side will have its length as an even integer, and the line drawn from the opposite vertex to the mid-point of the altered side is of integral length.
Since Rupsa is in a hurry to record a song for Chef as he really loves her songs, you must help her solve the problem as fast as possible.
-----Input-----
The first line of input contains an integer T denoting the number of test cases.
Each test-case contains a single integer N.
-----Output-----
For each test case, output "YES" if the triangle transformation is possible, otherwise "NO" (quotes for clarity only, do not output).
-----Constraints-----
- 1 ≤ T ≤ 106
- 1 ≤ N ≤ 5 x 106
-----Sub tasks-----
- Subtask #1: 1 ≤ T ≤ 100, 1 ≤ N ≤ 104 (10 points)
- Subtask #2: 1 ≤ T ≤ 104, 1 ≤ N ≤ 106 (30 points)
- Subtask #3: Original Constraints (60 points)
-----Example-----
Input:2
5
3
Output:YES
NO
-----Explanation-----
- In test case 1, make the length of any one side 6, and it will suffice.
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 isPos(num):
if num%2==0:
for i in range(num,2*num,1):
if ((num**2)-((i/2)**2))**(1/2)==int(((num**2)-((i/2)**2))**(1/2)):
return 'YES'
return 'NO'
else:
for i in range(num+1,2*num,1):
if ((num**2)-((i/2)**2))**(1/2)==int(((num**2)-((i/2)**2))**(1/2)):
return 'YES'
return 'NO'
test = int(input())
for __ in range(test):
num=int(input())
print(isPos(num))
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n5\n3\n",
"output": "YES\nNO\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/ADTRI"
} | vfc_3206 | false | false | false | false | false |
apps | verifiable_code | 1092 | Solve the following coding problem using the programming language python:
The faculty of application management and consulting services (FAMCS) of the Berland State University (BSU) has always been popular among Berland's enrollees. This year, N students attended the entrance exams, but no more than K will enter the university. In order to decide who are these students, there are series of entrance exams. All the students with score strictly greater than at least (N-K) students' total score gets enrolled.
In total there are E entrance exams, in each of them one can score between 0 and M points, inclusively. The first E-1 exams had already been conducted, and now it's time for the last tribulation.
Sergey is the student who wants very hard to enter the university, so he had collected the information about the first E-1 from all N-1 enrollees (i.e., everyone except him). Of course, he knows his own scores as well.
In order to estimate his chances to enter the University after the last exam, Sergey went to a fortune teller. From the visit, he learnt about scores that everyone except him will get at the last exam. Now he wants to calculate the minimum score he needs to score in order to enter to the university. But now he's still very busy with minimizing the amount of change he gets in the shops, so he asks you to help him.
-----Input-----
The first line of the input contains an integer T denoting the number of test cases. The description of T test cases follows.
The first line of each test case contains four space separated integers N, K, E, M denoting the number of students, the maximal number of students who'll get enrolled, the total number of entrance exams and maximal number of points for a single exam, respectively.
The following N-1 lines will contain E integers each, where the first E-1 integers correspond to the scores of the exams conducted. The last integer corresponds to the score at the last exam, that was predicted by the fortune-teller.
The last line contains E-1 integers denoting Sergey's score for the first E-1 exams.
-----Output-----
For each test case, output a single line containing the minimum score Sergey should get in the last exam in order to be enrolled. If Sergey doesn't have a chance to be enrolled, output "Impossible" (without quotes).
-----Constraints-----
- 1 ≤ T ≤ 5
- 1 ≤ K < N ≤ 104
- 1 ≤ M ≤ 109
- 1 ≤ E ≤ 4
-----Example-----
Input:1
4 2 3 10
7 7 7
4 6 10
7 10 9
9 9
Output:4
-----Explanation-----
Example case 1. If Sergey gets 4 points at the last exam, his score will be equal to 9+9+4=22. This will be the second score among all the enrollees - the first one will get 21, the second one will get 20 and the third will have the total of 26. Thus, Sergey will enter the university.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
# cook your dish here
t=int(input())
for i in range(t):
(n,k,e,m)=tuple(map(int,input().split()))
scores=[]
for j in range(n-1):
scores.append(sum(list(map(int,input().split()))))
scores.sort(reverse=True);
bsc=scores[k-1];
msc=sum(list(map(int,input().split())))
mini=bsc-msc+1
if(mini<0):
print(0)
elif(mini>m):
print("Impossible")
else:
print(mini)
``` | {
"language": "python",
"test_cases": [
{
"input": "1\n4 2 3 10\n7 7 7\n4 6 10\n7 10 9\n9 9\n",
"output": "4\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/ENTEXAM"
} | vfc_3210 | false | false | false | false | false |
apps | verifiable_code | 1093 | Solve the following coding problem using the programming language python:
Chef likes toys. His favourite toy is an array of length N. This array contains only integers. He plays with this array every day. His favourite game with this array is Segment Multiplication. In this game, the second player tells the left and right side of a segment and some modulo. The first player should find the multiplication of all the integers in this segment of the array modulo the given modulus. Chef is playing this game. Of course, he is the first player and wants to win all the games. To win any game he should write the correct answer for each segment. Although Chef is very clever, he has no time to play games. Hence he asks you to help him. Write the program that solves this problem.
-----Input-----
The first line of the input contains an integer N denoting the number of elements in the given array. Next line contains N integers Ai separated with spaces. The third line contains the number of games T. Each of the next T lines contain 3 integers Li, Ri and Mi, the left side of the segment, the right side of segment and the modulo.
-----Output-----
For each game, output a single line containing the answer for the respective segment.
-----Constrdaints-----
- 1 ≤ N ≤ 100,000
- 1 ≤ Ai ≤ 100
- 1 ≤ T ≤ 100,000
- 1 ≤ Li ≤ Ri ≤ N
- 1 ≤ Mi ≤ 109
-----Example-----
Input:
5
1 2 3 4 5
4
1 2 3
2 3 4
1 1 1
1 5 1000000000
Output:
2
2
0
120
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())
# # # # arr = list(map(int , input().split()))
# # # # for _ in range(int(input())):
# # # # l,r,mod = map(int , input().split())
# # # # pro = 1
# # # # for i in range(l - 1,r):
# # # # pro *= arr[i]
# # # # print(pro % mod) #sample testcases passed #TLE
# # # import numpy #or use math
# # # n = int(input())
# # # arr = list(map(int , input().split()))
# # # for _ in range(int(input())):
# # # l,r,mod = map(int , input().split())
# # # print(numpy.prod(arr[l - 1:r]) % mod) #sample cases passed, WA
# # import math
# # primes,dic,t = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97],{},0
# # for i in primes:
# # dic[i] = t
# # t += 1
# # def primeFactors(n,arr):
# # for i in range(2,int(math.sqrt(n)) + 1,2):
# # while(n % i == 0):
# # arr[dic[i]] += 1
# # n /= i
# # if(n > 2):
# # arr[dic[n]] += 1
# # return arr
# # n = int(input())
# # A = list(map(int , input().split()))
# # dp = [0]*len(primes)
# # for i in range(1,n + 1):
# # r = [dp[i - 1]].copy()
# # dp.append(primeFactors(A[i - 1],r))
# # for _ in range(int(input())):
# # li,ri,m=list(map(int,input().split()))
# # ans = 1
# # for i in range(len(primes)):
# # ans *= (pow(primes[i],dp[ri][i] - dp[li - 1][i],m)) % m
# # print(ans % m) #NZEC
# import math
# primes=[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]
# dic={}
# t=0
# for i in primes:
# dic[i]=t
# t+=1
# def primeFactors(n,arr):
# while(n % 2 == 0):
# arr[dic[2]] += 1
# n /= 2
# for i in range(3,int(math.sqrt(n))+1,2):
# while(n % i == 0):
# arr[dic[i]] += 1
# n /= i
# if(n > 2):
# arr[dic[n]] += 1
# return arr
# N = int(input())
# A = list(map(int , input().split()))
# dp = [[0]*len(primes)]
# for i in range(1,N + 1):
# r = dp[i - 1].copy()
# dp.append(primeFactors(A[i - 1],r))
# for _ in range(int(input())):
# l,r,m = list(map(int , input().split()))
# ans = 1
# for i in range(len(primes)):
# ans *= (pow(primes[i],dp[r][i] - dp[l - 1][i],m)) % m
# print(ans % m)
import sys
import math
input = sys.stdin.readline
primes=[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]
dic={}
t=0
for i in primes:
dic[i]=t
t+=1
def primeFactors(n,arr):
while n % 2 == 0:
arr[dic[2]]+=1
n = n / 2
for i in range(3,int(math.sqrt(n))+1,2):
while n % i== 0:
arr[dic[i]]+=1
n = n / i
if n > 2:
arr[dic[n]]+=1
return arr
def main():
N=int(input())
A=list(map(int,input().split()))
tp=[0]*len(primes)
dp=[]
dp.append(tp)
for i in range(1,N+1):
# print(i)
r=dp[i-1].copy()
t=primeFactors(A[i-1],r)
dp.append(t)
t=int(input())
for _ in range(t):
l,r,m=list(map(int,input().split()))
if(m==1):
print(0)
else:
ans=1
for i in range(len(primes)):
ans=ans*(pow(primes[i],dp[r][i]-dp[l-1][i],m))%m
print(ans%m)
def __starting_point():
main()
__starting_point()
``` | {
"language": "python",
"test_cases": [
{
"input": "5\n1 2 3 4 5\n4\n1 2 3\n2 3 4\n1 1 1\n1 5 1000000000\n",
"output": "2\n2\n0\n120\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/CHMOD"
} | vfc_3214 | false | false | false | false | false |
apps | verifiable_code | 1094 | Solve the following coding problem using the programming language python:
Two words rhyme if their last 3 letters are a match. Given N words, print the test case number (of the format Case : num) followed by the rhyming words in separate line adjacent to each other.
The output can be in anyorder.
-----Input-----
First line contains the number of test case T
The next line contains the number of words N
Next N words follow . They’ll contain only alphabets from ‘a’-‘z’.
-----Output-----
Print case number (for each test case) of the format Case : num followed by the words that rhyme in a new line.
-----Constraints-----
1 <= T <= 5
1 <= N <= 1000
3 <= length of each word <= 1000
-----Example-----
Input:
3
3
nope qwerty hope
5
brain drain request grain nest
4
these words dont rhyme
Output:
Case : 1
hope nope
qwerty
Case : 2
brain drain grain
nest request
Case : 3
these
dont
words
rhyme
-----Explanation-----
Case : 2
brain drain grain
nest request
Case : 3
these
dont
words
rhyme
Explanation for case 1: since hope and nope rhyme (suffix “ope” matches), we print them in the same line and qwerty In a new line.
Note that
qwerty
nope hope
is also correct (the output can be in any order )
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
t = int(input())
for i in range(t):
n = int(input())
suffixes = {}
xx = input().split()
for x in range(n):
try:
a = suffixes[xx[x][-3:]]
except Exception as e:
a = []
a.append(xx[x])
suffixes.update({xx[x][-3:]: a})
print("Case : %d" % (i + 1))
for a in sorted(suffixes):
print("".join(b + " " for b in sorted(suffixes[a])).strip())
``` | {
"language": "python",
"test_cases": [
{
"input": "3\n3\nnope qwerty hope\n5\nbrain drain request grain nest\n4\nthese words dont rhyme\n",
"output": "Case : 1\nhope nope\nqwerty\nCase : 2\nbrain drain grain\nnest request\nCase : 3\nthese\ndont\nwords\nrhyme\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/COWA2016/problems/CWAM1502"
} | vfc_3218 | false | false | false | false | false |
apps | verifiable_code | 1095 | Solve the following coding problem using the programming language python:
Indraneel has to sort the books in his library. His library has one long shelf. His books are numbered $1$ through $N$ and he wants to rearrange the books so that they appear in the sequence $1,2, ..., N$.
He intends to do this by a sequence of moves. In each move he can pick up any book from the shelf and insert it at a different place in the shelf. Suppose Indraneel has $5$ books and they are initially arranged in the order
21453214532 \quad 1 \quad 4 \quad 5 \quad 3
Indraneel will rearrange this in ascending order by first moving book $1$ to the beginning of the shelf to get
12453124531 \quad 2 \quad 4 \quad 5 \quad 3
Then, moving book $3$ to position $3$, he gets
12345123451 \quad 2 \quad 3 \quad 4 \quad 5
Your task is to write a program to help Indraneel determine the minimum number of moves that are necessary to sort his book shelf.
-----Input:-----
The first line of the input will contain a single integer $N$ indicating the number of books in Indraneel's library. This is followed by a line containing a permutation of $1, 2, ..., N$ indicating the intial state of Indraneel's book-shelf.
-----Output:-----
A single integer indicating the minimum number of moves necessary to sort Indraneel's book-shelf.
-----Constraints:-----
- $1 \leq N \leq 200000$.
- You may also assume that in $50 \%$ of the inputs, $1 \leq N \leq 5000$.
-----Sample Input-----
5
2 1 4 5 3
-----Sample Output-----
2
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
n=int(input())
arr=[int(x) for x in input().split()]
l=[1]*n
if sorted(arr)==arr:
print('0')
else:
for i in range(0,len(arr)):
for j in range(i):
if arr[i]>=arr[j] and l[i]<l[j]+1:
l[i]=l[j]+1
print(n-max(l))
``` | {
"language": "python",
"test_cases": [
{
"input": "5\n2 1 4 5 3\n",
"output": "2\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/IARCSJUD/problems/BOOKSORT"
} | vfc_3222 | false | false | false | false | false |
apps | verifiable_code | 1096 | Solve the following coding problem using the programming language python:
Zonal Computing Olympiad 2012, 26 Nov 2011
The year is 2102 and today is the day of ZCO. This year there are N contests and the starting and ending times of each contest is known to you. You have to participate in exactly one of these contests. Different contests may overlap. The duration of different contests might be different.
There is only one examination centre. There is a wormhole V that transports you from your house to the examination centre and another wormhole W that transports you from the examination centre back to your house. Obviously, transportation through a wormhole does not take any time; it is instantaneous. But the wormholes can be used at only certain fixed times, and these are known to you.
So, you use a V wormhole to reach the exam centre, possibly wait for some time before the next contest begins, take part in the contest, possibly wait for some more time and then use a W wormhole to return back home. If you leave through a V wormhole at time t1 and come back through a W wormhole at time t2, then the total time you have spent is (t2 - t1 + 1). Your aim is to spend as little time as possible overall while ensuring
that you take part in one of the contests.
You can reach the centre exactly at the starting time of the contest, if possible. And you can leave the examination centre the very second the contest ends, if possible. You can assume that you will always be able to attend at least one contest–that is, there will always be a contest such that there is a V wormhole before it and a W wormhole after it.
For instance, suppose there are 3 contests with (start,end) times (15,21), (5,10), and (7,25), respectively. Suppose the V wormhole is available at times 4, 14, 25, 2 and the W wormhole is available at times 13 and 21. In this case, you can leave by the V wormhole at time 14, take part in the contest from time 15 to 21, and then use the W wormhole at time 21 to get back home. Therefore the time you have spent is (21 - 14 + 1) = 8. You can check that you cannot do better than this.
-----Input format-----
The first line contains 3 space separated integers N, X, and Y, where N is the number of contests, X is the number of time instances when wormhole V can be used and Y is the number of time instances when wormhole W can be used. The next N lines describe each contest. Each of these N lines contains two space separated integers S and E, where S is the starting time of the particular contest and E is the ending time of that contest, with S < E. The next line contains X space separated integers which are the time instances when the wormhole V can be used. The next line contains Y space separated integers which are the time instances when the wormhole W can be used.
-----Output format-----
Print a single line that contains a single integer, the minimum time needed to be spent to take part in a contest.
-----Testdata-----
All the starting and ending times of contests are distinct and no contest starts at the same time as another contest ends. The time instances when wormholes are available are all distinct, but may coincide with starting and ending times of contests. All the time instances (the contest timings and the wormhole timings) will be integers between 1 and 1000000 (inclusive).
- Subtask 1 (30 marks)
- Subtask 2 (70 marks)
You may assume that
1 ≤ N ≤ 105,
1 ≤ X ≤ 105, and
1 ≤ Y ≤ 105.
In 30% of the cases,
1 ≤ N ≤ 103,
1 ≤ X ≤ 103, and
1 ≤ Y ≤ 103.
-----Sample Input-----
3 4 2
15 21
5 10
7 25
4 14 25 2
13 21
-----Sample Output-----
8
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
import sys
n, x, y = input().split(' ')
n = int(n)
x = int(x)
y = int(y)
contests = {}
for i in range(n):
s, e = input().split(' ')
s = int(s)
e = int(e)
contests[(s, e)] = abs(s-e)
v_time = input().split(' ')
w_time = input().split(' ')
v_time, w_time = list(map(int, v_time)), list(map(int, w_time))
v_time.sort()
w_time.sort()
score = sys.maxsize
contests = dict(sorted(contests.items(), key=lambda item: item[1]))
for k, v in contests.items():
start=-1
end = sys.maxsize
for i in range(x):
if v_time[i] > k[0]:
break
start = v_time[i]
for j in range(y):
if w_time[j] >= k[1]:
end = w_time[j]
break
if start == -1:
continue
score = min(score, (end-start+1))
if score-1 <= v:
break
print(score)
``` | {
"language": "python",
"test_cases": [
{
"input": "3 4 2\n15 21\n5 10\n7 25\n4 14 25 2\n13 21\n",
"output": "8\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/ZCOPRAC/problems/ZCO12002"
} | vfc_3226 | false | false | false | false | false |
apps | verifiable_code | 1097 | Solve the following coding problem using the programming language python:
Sinchan and his friends loves to eat. They have a 2D rectangular cake which they want to share. Sinchan is very kind and offers his friends to eat the cake first, all friends goes one by one to eat the cake. Each friend will cut cake into two parts. First part of the cake will be largest possible square from the cake, that the friend will eat, and will leave the second part for others, it continues untill cake is over or every friend gets to eat the cake.
Now Sinchan wonder how much cake would he be able to get.
-----Input-----
- First line of input contain T, denoting number of test case.
- First line of each test case contains N, denoting number of friends.
- Second line of test case contain L, B (L x B) denoting dimension of cake.
-----Output-----
- For each test case, if Sinchan gets to eat the cake print (without quotes) "Yes #" where # is area of cake that Sinchan gets. Otherwise print (without quotes) "No"
-----Constraints-----
- 1 ≤ T, N, L, B ≤ 1000
-----Example-----
Input:
3
2
5 3
4
4 8
1
1 2
Output:
Yes 2
No
Yes 1
-----Explanation-----
Example case 1. First friend divides 5x3 cake in 3x3 and 2x3 since 3x3 is largest possible square, second Friend divides 2x3 cake in 2x2 and 1x2 and eat 2x2 piece. Finaly Sinchan gets to eat and area of cake is 1*2 hence Output is (without quotes) "Yes 2"
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
testcases=int(input())
results=[]
for i in range(0,testcases):
friends=int(input())
l,b=list(map(int,input().split()))
over=False
if b>l:
temp=b
b=l
l=temp
for counter in range(0,friends):
if l==b:
over=True
break
elif l>b:
l=l-b
if b>l:
temp=b
b=l
l=temp
if over:
results.append("No")
else:
results.append("Yes "+str(l*b))
for i in range(0,testcases):
print(results[i])
``` | {
"language": "python",
"test_cases": [
{
"input": "3\n2\n5 3\n4\n4 8\n1\n1 2\n",
"output": "Yes 2\nNo\nYes 1\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/CDGO2016/problems/CDGO1601"
} | vfc_3230 | false | false | false | false | false |
apps | verifiable_code | 1098 | Solve the following coding problem using the programming language python:
Chef and Roma are playing a game. Rules of the game are quite simple.
Initially there are N piles of stones on the table.
In each turn, a player can choose one pile and remove it from the table.
Each player want to maximize the total number of stones removed by him.
Chef takes the first turn.
Please tell Chef the maximum number of stones he can remove assuming that both players play optimally.
-----Input-----
The first line of the input contains an integer T denoting the number of test cases. The description of T test cases follows.
The first line of each test case contains a single integer N denoting the number of piles.
The second line contains N space separated integers A1, A2, ..., AN denoting the number of stones in each pile.
-----Output-----
For each test case, output a single line containg the maximum number of stones that Chef can remove.
-----Constraints-----
- 1 ≤ Ai ≤ 109
- Subtask 1 (35 points): T = 10, 1 ≤ N ≤ 1000
- Subtask 2 (65 points): T = 10, 1 ≤ N ≤ 105
-----Example-----
Input:
2
3
1 2 3
3
1 2 1
Output:
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
for i in range(int(input())):
n = int(input())
l = list(map(int,input().split()))
s = 0
l.sort(reverse = True)
for i in range(0,n,2):
s = s+l[i]
print(s)
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n3\n1 2 3\n3\n1 2 1\n",
"output": "4\n3\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/CHEFA"
} | vfc_3234 | false | false | false | false | false |
apps | verifiable_code | 1099 | Solve the following coding problem using the programming language python:
Did you know that there are over 40,000 varieties of Rice in the world ? There are so many dishes that can be prepared with Rice too. A famous chef from Mumbai, Tid Gusto prepared a new dish and named it 'Tid Rice'. He posted the recipe in his newly designed blog for community voting, where a user can plus (+) or minus (-) the recipe. The final score is just the sum of all votes, where (+) and (-) are treated as +1 and -1 respectively. But, being just a chef ( and not a codechef ) he forgot to take care of multiple votes by the same user.
A user might have voted multiple times and Tid is worried that the final score shown is not the correct one. Luckily, he found the user logs, which had all the N votes in the order they arrived. Remember that, if a user votes more than once, the user's previous vote is first nullified before the latest vote is counted ( see explanation for more clarity ). Given these records in order ( and being a codechef yourself :) ), calculate the correct final score.
-----Input-----
First line contains T ( number of testcases, around 20 ). T cases follow. Each test case starts with N ( total number of votes, 1 <= N <= 100 ). Each of the next N lines is of the form "userid vote" ( quotes for clarity only ), where userid is a non-empty string of lower-case alphabets ( 'a' - 'z' ) not more than 20 in length and vote is either a + or - . See the sample cases below, for more clarity.
-----Output-----
For each test case, output the correct final score in a new line
-----Example-----
Input:
3
4
tilak +
tilak +
tilak -
tilak +
3
ratna +
shashi -
ratna -
3
bhavani -
bhavani +
bhavani -
Output:
1
-2
-1
Explanation
Case 1 : Initially score = 0. Updation of scores in the order of user tilak's votes is as follows,
( + ): +1 is added to the final score. This is the 1st vote by this user, so no previous vote to nullify. score = 1
( + ): 0 should be added ( -1 to nullify previous (+) vote, +1 to count the current (+) vote ). score = 1
( - ) : -2 should be added ( -1 to nullify previous (+) vote, -1 to count the current (-) vote ). score = -1
( + ): +2 should be added ( +1 to nullify previous (-) vote, +1 to count the current (+) vote ). score = 1
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
import sys
def f(p):
votes = {}
for x in range(p):
str = sys.stdin.readline()
t = str.split()
votes[t[0]] = t[1]
ans = 0
for per in votes:
if votes[per] == "+":
ans= ans+1
else:
ans = ans-1
return ans
x = sys.stdin.readline()
for t in range(int(x)):
p = sys.stdin.readline()
print(f(int(p)))
``` | {
"language": "python",
"test_cases": [
{
"input": "3\n4\ntilak +\ntilak +\ntilak -\ntilak +\n3\nratna +\nshashi -\nratna -\n3\nbhavani -\nbhavani +\nbhavani -\n",
"output": "1\n-2\n-1\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/COOK10/problems/TIDRICE"
} | vfc_3238 | false | false | false | false | false |
apps | verifiable_code | 1100 | Solve the following coding problem using the programming language python:
This question is similar to the $"Operation$ $on$ $a$ $Tuple"$ problem in this month's Long Challenge but with a slight variation.
Consider the following operations on a triple of integers. In one operation, you should:
- Choose a positive integer $d>0$ and an arithmetic operation - in this case, it will only be addition.
- Choose a subset of elements of the triple.
- Apply arithmetic operation to each of the chosen elements.
For example, if we have a triple $(3,5,7)$, we may choose to add $3$ to the first and third element, and we get $(6,5,10)$ using one operation.
You are given an initial triple $(p,q,r)$ and a target triple $(a,b,c)$. Find the maximum number of operations needed to transform $(p,q,r)$ into $(a,b,c)$ or say the conversion is impossible .
Input:
- The first line of the input contains a single integer T denoting the number of test cases. The description of T test cases follows.
- The first line of each test case contains three space-separated integers p, q and r.
- The second line contains three space-separated integers a, b and c.Output:
For each test case, print a single line containing one integer ― the maximum required number of operations(if the conversion is possible), or else print "-1"
Constraints:
- $1 \leq T \leq 1,000$
- $2 \leq |p|,|q|,|r|,|a|,|b|,|c| \leq 10^9$Sample Input:
1
2 2 1
3 3 2
Sample Output:
3
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
# cook your dish here
"""
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 three space-separated integers p, q and r.
The second line contains three space-separated integers a, b and c.
Output:
For each test case, print a single line containing one integer ― the maximum required number of operations(if the conversion is possible), or else print "-1"
"""
T=int(input())
while T>0:
T-=1
p,q,r=list(map(int,input().split()))
a,b,c=list(map(int,input().split()))
#ds=list()
s=0
d1=a-p
if d1>0:
#ds.append(d1)
s+=d1
d2=b-q
if d2>0:
#ds.append(d2)
s+=d2
d3=c-r
if d3>0:
#ds.append(d3)
s+=d3
if(d1==0 and d2==0 and d3==0):
print(0)
elif(d1<0 or d2<0 or d3<0):
print(-1)
else:
print(s)
``` | {
"language": "python",
"test_cases": [
{
"input": "1\n2 2 1\n3 3 2\n",
"output": "3\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/ENJU2020/problems/ECJN201"
} | vfc_3242 | false | false | false | false | false |
apps | verifiable_code | 1101 | Solve the following coding problem using the programming language python:
After failing to clear his school mathematics examination, infinitepro decided to prepare very hard for his upcoming re-exam, starting with the topic he is weakest at ― computational geometry.
Being an artist, infinitepro has C$C$ pencils (numbered 1$1$ through C$C$); each of them draws with one of C$C$ distinct colours. He draws N$N$ lines (numbered 1$1$ through N$N$) in a 2D Cartesian coordinate system; for each valid i$i$, the i$i$-th line is drawn with the ci$c_i$-th pencil and it is described by the equation y=ai⋅x+bi$y = a_i \cdot x + b_i$.
Now, infinitepro calls a triangle truly-geometric if each of its sides is part of some line he drew and all three sides have the same colour. He wants to count these triangles, but there are too many of them! After a lot of consideration, he decided to erase a subset of the N$N$ lines he drew. He wants to do it with his eraser, which has length K$K$.
Whenever erasing a line with a colour i$i$, the length of the eraser decreases by Vi$V_i$. In other words, when the eraser has length k$k$ and we use it to erase a line with a colour i$i$, the length of the eraser decreases to k−Vi$k-V_i$; if k<Vi$k < V_i$, it is impossible to erase such a line.
Since infinitepro has to study for the re-exam, he wants to minimise the number of truly-geometric triangles. Can you help him find the minimum possible number of truly-geometric triangles which can be obtained by erasing a subset of the N$N$ lines in an optimal way? He promised a grand treat for you if he passes the examination!
-----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 the input contains three space-separated integers N$N$, C$C$ and K$K$.
- N$N$ lines follow. For each i$i$ (1≤i≤N$1 \le i \le N$), the i$i$-th of these lines contains three space-separated integers ai$a_i$, bi$b_i$ and ci$c_i$.
- The last line contains C$C$ space-separated integers V1,V2,…,VC$V_1, V_2, \ldots, V_C$.
-----Output-----
For each test case, print a single line containing one integer ― the smallest possible number of truly-geometric triangles after erasing lines.
-----Constraints-----
- 1≤T≤10$1 \le T \le 10$
- 1≤C≤N≤3,000$1 \le C \le N \le 3,000$
- 0≤K≤3,000$0 \le K \le 3,000$
- 0≤ai,bi≤109$0 \le a_i, b_i \le 10^9$ for each valid i$i$
- 1≤ci≤C$1 \le c_i \le C$ for each valid i$i$
- 0≤Vi≤K$0 \le V_i \le K$ for each valid i$i$
- no two lines coincide, regardless of their colours
- no three lines are concurrent
-----Subtasks-----
Subtask #1 (10 points):
- N≤10$N \le 10$
- K≤100$K \le 100$
Subtask 2 (15 points):
- V1=V2=…=VC$V_1 = V_2 = \ldots = V_C$
- no two lines are parallel
Subtask #3 (25 points): no two lines are parallel
Subtask #4 (50 points): original constraints
-----Example Input-----
2
7 2 13
1 10 1
1 14 2
6 4 1
2 2 1
0 12 2
2 11 2
0 6 1
8 10
6 1 20
1 5 1
2 11 1
4 0 1
6 8 1
0 11 1
3 3 1
9
-----Example Output-----
2
4
-----Explanation-----
Example case 1: We can remove exactly one line. Initially, we have 5$5$ truly geometric triangles (see the image below; red is colour 1$1$ and green is colour 2$2$).
- Removing any line with colour 2$2$ brings the total number of truly-geometric triangles down to 4+0=4$4+0=4$.
- Removing any line with colour 1$1$ brings the total number of truly-geometric triangles down to 1+1=2$1+1=2$.
Thus, the smallest number of truly-geometric triangles we can obtain is 2$2$.
Example case 2: We can remove at most 2$2$ lines and removing any 2$2$ lines gives us a total of 4$4$ truly-geometric triangles.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
from collections import Counter
from math import factorial
def nc3(n):
a=factorial(n)
b=factorial(n-3)
return ((a)/(b*6))
def rem(s,k):
t=-1
x=-1
for i in range(len(s)):
if s[i][0]>2 and s[i][1]<=k:
if s[i][0]>3:
ch=(nc3(s[i][0])-nc3(s[i][0]-1))/s[i][1]
else:
ch=1/s[i][1]
if t<ch:
t=ch
x=i
return x
t=int(input())
for x in range(t):
n,c,k=map(int,input().split())
l={}
for i in range(n):
a,b,e=map(int,input().split())
if e in l:
l[e].append(a)
else:
l[e]=[]
l[e].append(a)
v=list(map(int,input().split()))
s=[]
for i in range(1,c+1):
if i in l:
s+=[[len(l[i]),v[i-1]]]
s.sort(key = lambda x: x[0],reverse=True)
while True:
ma=rem(s,k)
if ma<=-1:
break
else:
s[ma][0]-=1
k=k-s[ma][1]
re=0
for i in s:
if i[0]>2:
re=re+nc3(i[0])
print(int(re))
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n7 2 13\n1 10 1\n1 14 2\n6 4 1\n2 2 1\n0 12 2\n2 11 2\n0 6 1\n8 10\n6 1 20\n1 5 1\n2 11 1\n4 0 1\n6 8 1\n0 11 1\n3 3 1\n9\n",
"output": "2\n4\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/ACCBIP"
} | vfc_3246 | false | false | false | false | false |
apps | verifiable_code | 1102 | Solve the following coding problem using the programming language python:
On Miu's smart phone, there is a search feature which lets her search for a contact name by typing digits on the keypad where each digit may correspond to any of the characters given below it. For example, to search for TOM, she can type 866 and for MAX she can type 629.
+------+-----+------+
| 1 | 2 | 3 |
| | ABC | DEF |
+------+-----+------+
| 4 | 5 | 6 |
| GHI | JKL | MNO |
+------+-----+------+
| 7 | 8 | 9 |
| PQRS | TUV | WXYZ |
+------+-----+------+
| | 0 | |
+------+-----+------+
Miu typed a random string of digits $S$ on the keypad while playing around, where each digit is between 2 and 9 inclusive. Now she wants to know the number of possible strings which would map to $S$.
Since this number can be very large, output it modulo 10^9 + 7 (1000000007)
-----Input:-----
-
The first line of the input consists of a single integer $T$ denoting the number of test cases.
-
Each test case consists of a string $S$.
-----Output:-----
- For each test case, print a single line containing one integer - the count of all possible strings mod 1,000,000,007
-----Constraints-----
-
1 <= $T$ <= 10
-
1 <= $|S|$ <= 105
-----Subtasks-----
Subtask #1 (10 points):
- 1 <= $|S|$ <= 10
Subtask #2 (90 points):
- Original Constraints
-----Sample Input:-----
2
5
72
-----Sample Output:-----
3
12
-----EXPLANATION:-----
-
Example Case 1:
On the key 5, we have the character set JKL.
Hence the possible strings are J,K,L.
Hence the answer is 3 % (1000000007) = 3.
-
Example Case 2:
On key 7, we have the character set PQRS.
On key 2, we have the character set ABC.
Hence the possible strings are PA,PB,PC,QA,QB,QC,RA,RB,RC,SA,SB,SC.
Hence the answer is 12 % (1000000007) = 12.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
for _ in range(int(input())):
n=int(input())
n1=0
ans=1
while(n>0):
d=int(n % 10)
if(d!=0):
if(d!=9 and d!=7 and d!=1):
n1=3
elif(d==1):
n1=1
else:
n1=4
ans=(int(ans)*int(n1))% (1000000007)
n/=10
else:
n/=10
if(ans==1):
print("0")
else:
print(ans %(1000000007))
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n5\n72\n",
"output": "3\n12\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/TCFL2020/problems/TCFL20C"
} | vfc_3250 | false | false | false | false | false |
apps | verifiable_code | 1103 | Solve the following coding problem using the programming language python:
Leha is a bright mathematician. Today he is investigating whether an integer is divisible by some square number or not.
He has a positive integer X represented as a product of N integers a1, a2, .... aN. He has somehow figured out that there exists some integer P such that the number X is divisible by P2, but he is not able to find such P himself. Can you find it for him? If there are more than one possible values of P possible, you can print any one of them.
-----Input-----
The first line of the input contains an integer T denoting the number of test cases. T test cases follow.
The first line of each test case contains one integer N denoting the number of intgers in presentation of X.
The second line contains N space-separated integers a1, a2, .... aN.
-----Output-----
For each test case, output a single integer P deoting the answer for this test case. Note that P must be in range from 2 to 1018 inclusive. It's guaranteed that at least one answer exists. If there are more than one possible answers, print any.
-----Constraints-----
- 1 ≤ T ≤ 5
- 1 ≤ N ≤ 100
- 1 ≤ ai ≤ 1018
-----Subtasks-----
- Subtask 1[19 points]: 1 ≤ a1*a2*...*aN ≤ 106
- Subtask 2[22 points]: 1 ≤ a1*a2*...*aN ≤ 1012
- Subtask 3[23 points]: 1 ≤ ai ≤ 1012
- Subtask 4[36 points]: no additional constraints
-----Example-----
Input:
1
3
21 11 6
Output:
3
-----Explanation-----
Example case 1. X = 21 * 11 * 6 = 1386. It's divisible by 9 which is a square number, as 9 = 32. So P = 3.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
import sys
import math
r=int(input())
for v in range (0,r):
n = int(input())
x=1
arr=list(map(int,input().strip().split(" ")))
for i in range (0,n):
x=x*arr[i]
for i in range (2,100000000):
if(x%(pow(i,2))==0):
ans1=i
break
print(ans1)
``` | {
"language": "python",
"test_cases": [
{
"input": "1\n3\n21 11 6\n",
"output": "3\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/LTIME37/problems/SQNUMBF"
} | vfc_3254 | false | false | false | false | false |
apps | verifiable_code | 1104 | Solve the following coding problem using the programming language python:
Kabir Singh is playing a game on the non-negative side of x-axis. It takes him $1 second$ to reach from Pth position to (P−1)th position or (P+1)th position.
Kabir never goes to the negative side and also doesn't stop at any moment of time.
The movement can be defined as :
- At the beginning he is at $x=0$ , at time $0$
- During the first round, he moves towards $x=1$ and comes back to the $x=0$ position.
- In the second round, he moves towards the $x=2$ and comes back again to $x=0$.
- So , at $Kth$ round , he moves to $x=K$ and comes back to $x=0$
So in this way game goes ahead.
For Example, the path of Kabir for $3rd$ round is given below.
$0−1−2−3−2−1−0$
The overall path followed by Kabir would look somewhat like this:
$0−1−0−1−2−1−0−1−2−3−2−1−0−1−2−3−4−3−…$
Now the task is , You are given Two Non-Negative integers $N$ , $K$ .
You have to tell the time at which Kabir arrives at $x=N$ for the $Kth$ time.
Note - Kabir visits all the points , he can not skip or jump over one point.
-----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, K$.
-----Output:-----
For each testcase, output in a single line answer i.e Time Taken by Kabir Singh modulo 1000000007.
-----Constraints-----
- $1 \leq T \leq 10^5$
- $0 \leq N \leq 10^9$
- $1 \leq K \leq 10^9$
-----Sample Input:-----
4
0 1
1 1
1 3
4 6
-----Sample Output:-----
0
1
5
46
-----EXPLANATION:-----
Test Case 1:
Kabir starts the journey from the $N=0$ at time $t=0$ and it's the first time$ (K=1)$, he is here. So, the answer is $0$.
Test Case 3:
The path followed by Kabir to reach 1 for the third time is given below.
$0−1−0−1−2−1$
He reaches $1$ for the third time at $ t=5$.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
# cook your dish here
T=int(input())
MOD=int(1e9+7)
for t in range(T):
N,K=[int(a) for a in input().split()]
M=K//2
# ans= ((K%2)?( (N+M)*(N+M) + M ):( (N+M)*(N+M) - M) )
ans=(N+M)*(N+M) -M
if(K%2):
ans+=2*M
if(N==0):
ans=K*(K-1)
print(ans%MOD)
``` | {
"language": "python",
"test_cases": [
{
"input": "4\n0 1\n1 1\n1 3\n4 6\n",
"output": "0\n1\n5\n46\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/LDT42020/problems/WALKREC"
} | vfc_3258 | false | false | false | false | false |
apps | verifiable_code | 1105 | Solve the following coding problem using the programming language python:
Chef Ada is preparing $N$ dishes (numbered $1$ through $N$). For each valid $i$, it takes $C_i$ minutes to prepare the $i$-th dish. The dishes can be prepared in any order.
Ada has a kitchen with two identical burners. For each valid $i$, to prepare the $i$-th dish, she puts it on one of the burners and after $C_i$ minutes, removes it from this burner; the dish may not be removed from the burner before those $C_i$ minutes pass, because otherwise it cools down and gets spoiled. Any two dishes may be prepared simultaneously, however, no two dishes may be on the same burner at the same time. Ada may remove a dish from a burner and put another dish on the same burner at the same time.
What is the minimum time needed to prepare all dishes, i.e. reach the state where all dishes are prepared?
-----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 $C_1, C_2, \ldots, C_N$.
-----Output-----
For each test case, print a single line containing one integer ― the minimum number of minutes needed to prepare all dishes.
-----Constraints-----
- $1 \le T \le 1,000$
- $1 \le N \le 4$
- $1 \le C_i \le 5$ for each valid $i$
-----Subtasks-----
Subtask #1 (1 points): $C_1 = C_2 = \ldots = C_N$
Subtask #2 (99 points): original constraints
-----Example Input-----
3
3
2 2 2
3
1 2 3
4
2 3 4 5
-----Example Output-----
4
3
7
-----Explanation-----
Example case 1: Place the first two dishes on the burners, wait for two minutes, remove both dishes and prepare the last one on one burner.
Example case 2: Place the first and third dish on the burners. When the first dish is prepared, remove it and put the second dish on the same burner.
Example case 3: Place the third and fourth dish on the burners. When the third dish is prepared, remove it and put the second dish on the same burner. Similarly, replace the fourth dish (when it is prepared) by the first dish on the other burner.
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())
c=[int(z) for z in input().split()]
c.sort()
c.reverse()
b1,b2=0,0
for i in range(n):
if b1<b2:
b1+=c[i]
elif b2<b1:
b2+=c[i]
else:
b1+=c[i]
print(max(b1,b2))
``` | {
"language": "python",
"test_cases": [
{
"input": "3\n3\n2 2 2\n3\n1 2 3\n4\n2 3 4 5\n",
"output": "4\n3\n7\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/ADADISH"
} | vfc_3262 | false | false | false | false | false |
apps | verifiable_code | 1106 | Solve the following coding problem using the programming language python:
A long way back I have taken $5000 from Golu when I used to live in Jodhpur. Now, time has passed and I am out of Jodhpur. While Golu still in Jodhpur, one day called me and asked about his money.
I thought of giving Golu a chance. I told him that he can still take his money back if he reaches my home anyhow just in 2 days but not after that.
In excitement he made his way toward my hometown i.e. Gorakhpur. To cover up the petrol cost he started giving paid lift to whoever needs it throughout the way in order to earn some money. Help him to get the maximum profit.
His car has a capacity of k + 1 person, so in a certain moment he can transport k persons (and himself).
From Jodhpur to Gorakhpur, there are l localities (cities, towns, villages), Jodhpur being the first and Gorakhpur being the lth.
There are n groups of lift takers along the road. The ith
group consists of pi persons, wants to travel from locality si to locality di and will pay an amount of mi money.
A group must be taken into the car as a whole. Assume that lift takers are found only in localities.
Restrictions
• 1 ≤ k ≤ 7
• 1 ≤ l ≤ 1000000
• 1 ≤ n ≤ 50
• 1 ≤ pi ≤ k
• 1 ≤ si ≤ l – 1
• 2 ≤ di ≤ l
• si < di
• 1 ≤ mi ≤ 1000000
-----Input-----
The first line of the input contains the number of test cases.
The first line of each test case contains the numbers n, l and k separated by a single space.
n lines follow, the ith line containing pi, si, di and mi separated by a single space.
-----Output-----
For each test case output a single line containing the maximum amount of money Golu can earn.
-----Example-----
Input:
2
5 5 4
2 1 5 50
1 2 4 20
2 3 4 40
2 4 5 50
3 4 5 80
10 10 5
2 5 10 17300
2 1 8 31300
5 4 10 27600
4 8 10 7000
5 9 10 95900
2 7 10 14000
3 6 10 63800
1 7 10 19300
3 8 10 21400
2 2 10 7000
Output:
140
127200
By:
Chintan, Asad, Ashayam, Akanksha
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
'''Well I found the bug, but I don't understand why it was doing that. I mean, as
far as I can tell, it shouldn't be a bug!
Note to self: deleting from (supposedly) local lists through recursion is dangerous!'''
class Group(object):
def __init__(self,size,start,end,value):
self.size = size
self.start = start
self.end = end
self.value = value
def __lt__(self,other):
return self.start < other.start
def __str__(self):
return "%i: %i->%i, $%i" %(self.size,self.start,self.end,self.value)
def hash(car,i):
people = []
for group in car:
people.extend([group.end]*group.size)
people.sort()
return tuple(people+[i])
def optimize(groups,car,capacity,i):
if i == len(groups):
return 0
newcar = []
pos = groups[i].start
for group in car:
if group.end > pos:
newcar.append(group)
else:
capacity += group.size
state = hash(newcar,i)
try:
return memo[state]
except:
v = optimize(groups,newcar,capacity,i+1)
if groups[i].size <= capacity:
w = optimize(groups,newcar+[groups[i]],capacity-groups[i].size,i+1) + groups[i].value
else:
w = 0
if v > w:
ie[state] = -1
elif v < w:
ie[state] = 1
else:
ie[state] = 0
ans = max(v,w)
memo[state] = ans
return ans
cases = int(input())
for case in range(cases):
memo = {}
ie = {}
groups = []
n,_,capacity = list(map(int,input().split()))
for g in range(n):
size,start,end,value = list(map(int,input().split()))
groups.append(Group(size,start,end,value))
groups.sort()
print(optimize(groups,[],capacity,0))
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n5 5 4\n2 1 5 50\n1 2 4 20\n2 3 4 40\n2 4 5 50\n3 4 5 80\n10 10 5\n2 5 10 17300\n2 1 8 31300\n5 4 10 27600\n4 8 10 7000\n5 9 10 95900\n2 7 10 14000\n3 6 10 63800\n1 7 10 19300\n3 8 10 21400\n2 2 10 7000\n",
"output": "140\n127200\nBy:\nChintan, Asad, Ashayam, Akanksha\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/IGNS2012/problems/IG02"
} | vfc_3266 | false | false | false | false | false |
apps | verifiable_code | 1107 | Solve the following coding problem using the programming language python:
Polo, the Penguin, likes numbers. He says that the goodness of a number is itself multiplied by the number of digits in it's decimal representation. For example, the goodness of the integer 474 is 474*3 = 1422.
Help him to count the sum of goodness of all integers from L to R, inclusive. Since the answer can be too large, output it modulo 1,000,000,007 (10^9+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 only line of each test case contains the pair of integers L and R, separated by a single space.
-----Output-----
For each test case, output a single line containing the answer to the corresponding test case.
-----Constraints-----
- 1 ≤ T ≤ 1,000
- 1 ≤ L ≤ R ≤ 1,000,000,000 (10^9)
-----Example-----
Input:
1
9 12
Output:
75
-----Explanation-----
Example case 1. The answer is 9*1 + 10*2 + 11*2 + 12*2 = 75.
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
from math import sqrt,ceil,log10
def get_sum(a,b,digits):
sum=((b+a)*(b-a+1))//2
return sum*digits
def solve():
mod=10**9+7
thehighlimiter={i: 10 ** i - 1 for i in range(12)}
thelowlimiter={i: 10**i for i in range(12)}
for _ in range(int(input())):
l,r=map(int, stdin.readline().strip().split())
low=len(str(l))
high=len(str(r))
ans=0
if low==high:
ans=get_sum(l,r,low)
else:
ans+=get_sum(l,((10**low)-1),low)
ans+=get_sum((10**(high-1)),r,high)
for i in range(low+1,high):
ans+=get_sum(10**(i-1),(10**i)-1,i)
print(ans%mod)
def __starting_point():
solve()
__starting_point()
``` | {
"language": "python",
"test_cases": [
{
"input": "1\n9 12\n\n\n",
"output": "75\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/PPNUM"
} | vfc_3270 | false | false | false | false | false |
apps | verifiable_code | 1108 | Solve the following coding problem using the programming language python:
There were $N$ students (numbered $1$ through $N$) participating in the Indian Programming Camp (IPC) and they watched a total of $K$ lectures (numbered $1$ through $K$). For each student $i$ and each lecture $j$, the $i$-th student watched the $j$-th lecture for $T_{i, j}$ minutes.
Additionally, for each student $i$, we know that this student asked the question, "What is the criteria for getting a certificate?" $Q_i$ times.
The criteria for getting a certificate is that a student must have watched at least $M$ minutes of lectures in total and they must have asked the question no more than $10$ times.
Find out how many participants are eligible for a certificate.
-----Input-----
- The first line of the input contains three space-separated integers $N$, $M$ and $K$.
- $N$ lines follow. For each valid $i$, the $i$-th of these lines contains $K+1$ space-separated integers $T_{i, 1}, T_{i, 2}, \ldots, T_{i, K}, Q_i$.
-----Output-----
Print a single line containing one integer — the number of participants eligible for a certificate.
-----Constraints-----
- $1 \le N, K \le 1,000$
- $1 \le M \le 10^6$
- $1 \le Q_i \le 10^6$ for each valid $i$
- $1 \le T_{i, j} \le 1,000$ for each valid $i$ and $j$
-----Example Input-----
4 8 4
1 2 1 2 5
3 5 1 3 4
1 2 4 5 11
1 1 1 3 12
-----Example Output-----
1
-----Explanation-----
- Participant $1$ watched $1 + 2 + 1 + 2 = 6$ minutes of lectures and asked the question $5$ times. Since $6 < M$, this participant does not receive a certificate.
- Participant $2$ watched $3 + 5 + 1 + 3 = 12$ minutes of lectures and asked the question $4$ times. Since $12 \ge M$ and $4 \le 10$, this participant receives a certificate.
- Participant $3$ watched $1 + 2 + 4 + 5 = 12$ minutes of lectures and asked the question $11$ times. Since $12 \ge M$ but $11 > 10$, this participant does not receive a certificate.
- Participant $4$ watched $1 + 1 + 1 + 3 = 6$ minutes of lectures and asked the question $12$ times. Since $6 < M$ and $12 > 10$, this participant does not receive a certificate.
Only participant $2$ receives a certificate.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
N,M,K=map(int,input().split())
c=0
for i in range(N):
T=list(map(int,input().split()))
Q=T[-1]
T.pop(-1)
if Q<=10 and sum(T)>=M:
c+=1
print(c)
``` | {
"language": "python",
"test_cases": [
{
"input": "4 8 4\n1 2 1 2 5\n3 5 1 3 4\n1 2 4 5 11\n1 1 1 3 12\n",
"output": "1\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/IPCCERT"
} | vfc_3274 | false | false | false | false | false |
apps | verifiable_code | 1109 | Solve the following coding problem using the programming language python:
Sumit and Dhiraj are roommates in a hostel of NIT Jamshedpur,One day after completing there boring assignments of Artificial Intelligence, they decided to play a game as it was dhiraj,s idea to play a game so he started explaining the rules of the game to sumit.
So the game was as follows-They randomly took a number N after that they find all its divisors.Suppose first sumit took a divisor then dhiraj and so on.The player who will be having the last divisor with him will win the game.Rohit their mutual friend,was observing them play. Can you help Rohit predict the outcome of game? If Sumit wins print "YES" without quotes and "NO" without quotes, if Dhiraj wins
the game.
-----Input-----
Input starts with an integer T denoting the number of test cases Each test case starts with a line containing an integer N the number.
-----Output-----
Outcome of each game in a separate line
-----Constraints-----
- 1 ≤ T ≤ 10^3
- 1 ≤ N ≤ 10^18
-----Sub tasks-----
- Subtask #1:(10 points)
- 1 ≤ T ≤ 10
- 1 ≤ N ≤ 103
- Subtask #2:(25 points)
- 1 ≤ T ≤ 50
- 1 ≤ N ≤ 1016
- Subtask #3:(65 points)
- 1 ≤ T ≤ 103
- 1 ≤ N ≤ 1018
-----Example-----
Input:
2
4
5
Output:
YES
NO
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
import math
for t in range(int(input())):
n = int(input())
temp = math.sqrt(n)
if (temp == int(temp)):
print("YES")
else:
print("NO")
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n4\n5\n",
"output": "YES\nNO\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/COYA2016/problems/CDYPA01"
} | vfc_3278 | false | false | false | false | false |
apps | verifiable_code | 1110 | Solve the following coding problem using the programming language python:
You are given an array of integers [A1,A2,…,AN]$[A_1, A_2, \ldots, A_N]$. Let's call adding an element to this array at any position (including the beginning and the end) or removing an arbitrary element from it a modification. It is not allowed to remove an element from the array if it is empty.
Find the minimum number of modifications which must be performed so that the resulting array can be partitioned into permutations. Formally, it must be possible to partition elements of the resulting array into zero or more groups (multisets; not necessarily identical) in such a way that each element belongs to exactly one group and for each group, if it contains L$L$ elements, then it must contain only integers 1$1$ through L$L$, each of them exactly once.
-----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$.
-----Output-----
For each test case, print a single line containing one integer ― the minimum required number of modifications.
-----Constraints-----
- 1≤T≤1,000$1 \le T \le 1,000$
- 1≤N≤106$1 \le N \le 10^6$
- 1≤Ai≤109$1 \le A_i \le 10^9$ for each valid i$i$
- the sum of N$N$ over all test cases does not exceed 106$10^6$
-----Subtasks-----
Subtask #1 (50 points):
- 1≤N≤1,000$1 \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-----
2
5
1 4 1 2 2
4
2 3 2 3
-----Example Output-----
1
2
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
# cook your dish here
for _ in range(int(input())):
n=int(input());li=list(map(int,input().split()));dli=dict();modi=0
for i in li:
if i not in dli:dli[i]=1
else:dli[i]+=1
op=sorted(list(dli))
if(len(dli)!=0):
while 1:
tmp=[]
for i in op:
if dli[i]==0:continue
tmp.append(i);dli[i]-=1
l=len(tmp);mn=l
for i in range(l):mn=min(mn,tmp[i]-1-i+l-1-i)
modi+=mn
if(l==0):break
print(modi)
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n5\n1 4 1 2 2\n4\n2 3 2 3\n",
"output": "1\n2\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/PERMPART"
} | vfc_3282 | false | false | false | false | false |
apps | verifiable_code | 1111 | Solve the following coding problem using the programming language python:
Using his tip-top physique, Kim has now climbed up the mountain where the base is located. Kim has found the door to the (supposedly) super secret base. Well, it is super secret, but obviously no match for Kim's talents.
The door is guarded by a row of $N$ buttons. Every button has a single number $A_i$ written on it. Surprisingly, more than one button can have the same number on it. Kim recognises this as Soum's VerySafe door, for which you need to press two buttons to enter the password. More importantly, the sum of the two numbers on the buttons you press must be odd. Kim can obviously break through this door easily, but he also wants to know how many different pairs of buttons he can pick in order to break through the door.
Can you help Kim find the number of different pairs of buttons he can press to break through the door?
Note: Two pairs are considered different if any of the buttons pressed in the pair is different (by position of the button pressed). Two pairs are not considered different if they're the same position of buttons, pressed in a different order.
Please refer to the samples for more details.
-----Input:-----
- The first line contains a single integer $T$, representing the number of testcases. $2T$ lines follow, 2 for each testcase.
- For each testcase, the first line contains a single integer $N$, the number of buttons.
- The second line of each testcase contains $N$ space-separated integers, $A_1, A_2, \ldots, A_N$, representing the numbers written on each button.
-----Output:-----
Print a single number, $K$, representing the number of pairs of buttons in $A$ which have an odd sum.
-----Subtasks-----
For all subtasks, $1 \leq T \leq 10$, $1 \leq N \leq 100000$, and $1 \leq A_i \leq 100000$ for all $A_i$.
Subtask 1 [15 points] : $N \leq 2$, There are at most 2 buttons
Subtask 2 [45 points] : $N \leq 1000$, There are at most 1000 buttons
Subtask 3 [40 points] : No additional constraints.
-----Sample Input:-----
3
4
3 5 3 4
2
5 7
1
4
-----Sample Output:-----
3
0
0
-----EXPLANATION:-----
This section uses 1-indexing.
In the first sample, the buttons are: $[3, 5, 3, 4]$
$A[1] + A[4] = 3 + 4 = 7$ which is odd.
$A[2] + A[4] = 5 + 4 = 9$ which is odd.
$A[3] + A[4] = 3 + 4 = 7$ which is odd.
In total, there are 3 pairs with an odd sum, so the answer is 3.
In the second sample, the buttons are: $[5, 7]$. There are no odd pairs, so the answer is $0$.
In the third sample, the buttons are: $[4]$. There are no pairs at all, so the answer is $0$.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
# cook your dish here
for _ in range(int(input())):
n=int(input())
a=list(map(int,input().split()))
even=[]
odd=[]
for i in a:
if(i & 1):
even.append(i)
else:
odd.append(i)
print(len(even)*len(odd))
``` | {
"language": "python",
"test_cases": [
{
"input": "3\n4\n3 5 3 4\n2\n5 7\n1\n4\n",
"output": "3\n0\n0\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/UWCOI20B"
} | vfc_3286 | false | false | false | false | false |
apps | verifiable_code | 1112 | 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:-----
1
12
3
123
45
6
1234
567
89
10
-----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
# cook your dish here
for _ in range(int(input())):
n = int(input())
m = n
x= 1
for i in range(n):
for j in range(m):
print(x, end = '')
x += 1
print()
m -= 1
``` | {
"language": "python",
"test_cases": [
{
"input": "4\n1\n2\n3\n4\n",
"output": "1\n12\n3\n123\n45\n6\n1234\n567\n89\n10\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/PSTR2020/problems/ITGUY58"
} | vfc_3290 | false | false | false | false | false |
apps | verifiable_code | 1113 | Solve the following coding problem using the programming language python:
Given an array A of length N, your task is to find the element which repeats in A maximum number of times as well as the corresponding count. In case of ties, choose the smaller element first.
-----Input-----
First line of input contains an integer T, denoting the number of test cases. Then follows description of T cases. Each case begins with a single integer N, the length of A. Then follow N space separated integers in next line. Assume that 1 <= T <= 100, 1 <= N <= 100 and for all i in [1..N] : 1 <= A[i] <= 10000
-----Output-----
For each test case, output two space separated integers V & C. V is the value which occurs maximum number of times and C is its count.
-----Example-----
Input:
2
5
1 2 3 2 5
6
1 2 2 1 1 2
Output:
2 2
1 3
Description:
In first case 2 occurs twice whereas all other elements occur only once.
In second case, both 1 and 2 occur 3 times but 1 is smaller than 2.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
t = input();
a = [0 for i in range(10001)]
i = 0;
while i < int(t):
n = input();
k = input();
assert(len(k.split(' ')) == int(n));
for each in k.split(' '):
a[int(each)] += 1;
V = 0;
C = a[V];
for j in range(10001):
if C < a[j]:
V = j;
C = a[V];
a[j] = 0;
i += 1;
print(V, C);
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n5\n1 2 3 2 5\n6\n1 2 2 1 1 2\n\n\n",
"output": "2 2\n1 3\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/FEB12/problems/MAXCOUNT"
} | vfc_3294 | false | false | false | false | false |
apps | verifiable_code | 1114 | Solve the following coding problem using the programming language python:
Chefu is Chef's little brother, he is 12 years old and he is new to competitive programming.
Chefu is practicing very hard to become a very skilled competitive programmer and win gold medal in IOI.
Now Chefu is participating in a contest and the problem that he is trying to solve states:
Given an array A of N integers, find any i, j such that i < j
and Ai + Aj is maximum possible
unfortunately, there's no much time left before the end of the contest, so Chefu doesn't have time to think of correct solution, so instead, he wrote a solution that selects a random pair (i, j) (i < j) and output Ai + Aj. each pair is equiprobable to be selected.
Now Chefu wants your help to calculate the probability that his solution will pass a particular input.
-----Input-----
First line contains an integer T denoting the number of test-cases.
First line of each test-case contains a single integer N
Second line of each test-case contains N space-separated integers A1 A2 ... AN
-----Output-----
For each test-case output a single line containing a single number denoting the probability that Chefu's solution to output a correct answer. your answer will be accepted if the absolute difference between it and correct answer is less than 1e-6
-----Constraints-----
- 1 ≤ T ≤ 100
- 2 ≤ N ≤ 100
- 1 ≤ Ai ≤ 1,000
-----Example-----
Input:
3
4
3 3 3 3
6
1 1 1 2 2 2
4
1 2 2 3
Output:
1.00000000
0.20000000
0.33333333
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
T=int(input())
for i in range(T):
N=int(input())
A=list(map(int,input().split()))[:N]
l=[]
for j in range(len(A)):
for k in range(j+1,len(A)):
l.append(A[j]+A[k])
print(l.count(max(l))/((N*(N-1))/2))
``` | {
"language": "python",
"test_cases": [
{
"input": "3\n4\n3 3 3 3\n6\n1 1 1 2 2 2\n4\n1 2 2 3\n",
"output": "1.00000000\n0.20000000\n0.33333333\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/RNDPAIR"
} | vfc_3298 | false | false | false | false | false |
apps | verifiable_code | 1115 | Solve the following coding problem using the programming language python:
You are given a tree with $N$ vertices (numbered $1$ through $N$) and a sequence of integers $A_1, A_2, \ldots, A_N$. You may choose an arbitrary permutation $p_1, p_2, \ldots, p_N$ of the integers $1$ through $N$. Then, for each vertex $i$, you should assign the value $A_{p_i}$ to this vertex.
The profit of a path between two vertices $u$ and $v$ is the sum of the values assigned to the vertices on that path (including $u$ and $v$).
Let's consider only (undirected) paths that start at a leaf and end at a different leaf. Calculate the maximum possible value of the sum of profits of all such paths. Since this value could be very large, compute it modulo $10^9 + 7$.
-----Input-----
- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
- The first 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$.
- Each of the following $N−1$ lines contains two space-separated integers $u$ and $v$ denoting that vertices $u$ and $v$ are connected by an edge.
-----Output-----
For each test case, print a single line containing one integer — the maximum sum of profits, modulo $10^9 + 7$.
-----Constraints-----
- $1 \le T \le 1,000$
- $1 \le N \le 300,000$
- $1 \le A_i \le 10^9$ for each valid $i$
- the sum of $N$ over all test cases does not exceed $5 \cdot 10^5$
-----Example Input-----
2
4
1 2 3 4
1 2
2 3
2 4
5
1 2 3 4 5
1 2
2 3
3 4
4 5
-----Example Output-----
24
15
-----Explanation-----
Example case 1: $(1, 4, 2, 3)$ is one of the possible permutations that give the optimal answer. Then, the profits of paths between pairs of vertices $(1, 3)$, $(1, 4)$ and $(3, 4)$ are $7$, $8$ and $9$ respectively.
Example case 2: Here, any permutation could be chosen.
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())
M = 10 ** 9 + 7
for _ in range(T):
N = int(input())
A = list(map(int, input().split()))
if N == 1:
print(0)
continue
B = {}
C = {}
for i in range(N - 1):
u, v = input().split()
u = int(u) - 1
v = int(v) - 1
if u not in B:
B[u] = []
if v not in B:
B[v] = []
B[u].append(v)
B[v].append(u)
total_leaves = 0
for i in B:
if len(B[i]) == 1:
total_leaves += 1
S = [0]
visited = [False] * N
parent = [-1] * N
total_visits = [0] * N
while len(S) > 0:
current = S.pop(len(S) - 1)
if visited[current]:
p = parent[current]
if p != -1:
total_visits[p] += total_visits[current]
if p not in C:
C[p] = {}
C[p][current] = total_visits[current]
if current not in C:
C[current] = {}
C[current][p] = total_leaves - C[p][current]
else:
S.append(current)
visited[current] = True
for i, j in enumerate(B[current]):
if not visited[j]:
parent[j] = current
S.append(j)
if len(B[current]) == 1:
total_visits[current] = 1
p = parent[current]
if p != -1:
if p not in C:
C[p] = {}
C[p][current] = 1
D = {}
for i in C:
sum1 = 0
for j in C[i]:
sum1 += C[i][j]
D[i] = sum1
E = [0] * N
for i in C:
sum1 = 0
for j in C[i]:
D[i] -= C[i][j]
sum1 += C[i][j] * D[i]
E[i] = sum1
for i, j in enumerate(E):
if j == 0:
for k in C[i]:
E[i] = C[i][k]
E.sort()
E.reverse()
A.sort()
A.reverse()
E = [x % M for x in E]
A = [x % M for x in A]
ans = 0
for i, j in zip(E, A):
a = i * j
a %= M
ans += a
ans %= M
print(ans)
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n4\n1 2 3 4\n1 2\n2 3\n2 4\n5\n1 2 3 4 5\n1 2\n2 3\n3 4\n4 5\n",
"output": "24\n15\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/PRT"
} | vfc_3302 | false | false | false | false | true |
apps | verifiable_code | 1116 | Solve the following coding problem using the programming language python:
-----Problem Statement-----
We have an integer sequence $A$, whose length is $N$.
Find the number of the non-empty contiguous subsequences of $A$ whose sum is $0$. Note that we are counting the ways to take out subsequences. That is, even if the contents of some two subsequences are the same, they are counted individually if they are taken from different positions.
-----Input-----
Input is given in the following format:
$N$
$A_1$ $A_2$ . . . $A_N$
-----Output-----
Find the number of the non-empty contiguous subsequences of $A$ whose sum is $0$.
-----Constraints-----
- $1 \leq N \leq 2\times10^5$
- $-10^9 \leq A_i \leq 10^9$
- All values in input are integers.
-----Sample Input-----
6
1 3 -4 2 2 -2
-----Sample Output-----
3
-----EXPLANATION-----
There are three contiguous subsequences whose sums are $0$: $(1, 3, -4)$, $(-4, 2, 2)$ and $(2, -2)$
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
from collections import defaultdict
def findSubarraySum(arr, n, Sum):
# Dictionary to store number of subarrays
# starting from index zero having
# particular value of sum.
prevSum = defaultdict(lambda : 0)
res = 0
# Sum of elements so far.
currsum = 0
for i in range(0, n):
# Add current element to sum so far.
currsum += arr[i]
# If currsum is equal to desired sum,
# then a new subarray is found. So
# increase count of subarrays.
if currsum == Sum:
res += 1
# currsum exceeds given sum by currsum - sum.
# Find number of subarrays having
# this sum and exclude those subarrays
# from currsum by increasing count by
# same amount.
if (currsum - Sum) in prevSum:
res += prevSum[currsum - Sum]
# Add currsum value to count of
# different values of sum.
prevSum[currsum] += 1
return res
n=int(input())
lst=list(map(int,input().split()))
if(n==1):
if(lst[0]==0):
print(1)
else:
print(0)
else:
print(findSubarraySum(lst,n,0))
``` | {
"language": "python",
"test_cases": [
{
"input": "6\n1 3 -4 2 2 -2\n",
"output": "3\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/SCAT2020/problems/SC_01"
} | vfc_3306 | false | false | false | false | false |
apps | verifiable_code | 1117 | Solve the following coding problem using the programming language python:
It is the end of 2019 — the 17th of November, the Cooking Challenge day.
There are N$N$ players participating in this competition, numbered 1$1$ through N$N$. Initially, the skill level of each player is zero. There are also M$M$ challenges (numbered 1$1$ through M$M$). For each valid i$i$, the i$i$-th challenge has three parameters Li$L_i$, Ri$R_i$ and Xi$X_i$ with the following meaning: for each player between the Li$L_i$-th and Ri$R_i$-th inclusive, if this player participates in this challenge, their skill level increases by Xi$X_i$ (Xi$X_i$ does not have to be positive).
The organizers of the Cooking Challenge decided that the contest would be boring if they let the participants participate in the challenges directly, so they decided to use the compos.
There are Q$Q$ compos (numbered 1$1$ through Q$Q$). For each valid i$i$, the i$i$-th compo has two parameters Ai$A_i$ and Bi$B_i$, which means that it includes the challenges Ai,Ai+1,…,Bi$A_i, A_i+1, \ldots, B_i$.
Each participant has to select a subset of the compos (possibly empty or the set of all Q$Q$ compos) and participate in all challenges those compos include. A participant may not select the same compo twice, but may participate in the same challenge more than once if it is included in multiple chosen compos.
For each player, find the maximum skill level this player can reach if the compos are chosen optimally.
-----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$, M$M$ and Q$Q$.
- M$M$ lines follow. For each valid i$i$, the i$i$-th of these lines contains three space-separated integers Li$L_i$, Ri$R_i$ and Xi$X_i$.
- Q$Q$ more lines follow. For each valid i$i$, the i$i$-th of these lines contains two space-separated integers Ai$A_i$ and Bi$B_i$.
-----Output-----
For each test case, print a single line containing N$N$ space-separated integers. For each valid i$i$, the i$i$-th of these integers should denote the maximum skill level of the i$i$-th player.
-----Constraints-----
- 1≤T≤1,000$1 \le T \le 1,000$
- 1≤N≤100,000$1 \le N \le 100,000$
- 1≤M≤1,000$1 \le M \le 1,000$
- 1≤Q≤10,000$1 \le Q \le 10,000$
- 1≤Li≤Ri≤N$1 \le L_i \le R_i \le N$ for each valid i$i$
- 1≤Ai≤Bi≤M$1 \le A_i \le B_i \le M$ for each valid i$i$
- |Xi|≤1,000,000$|X_i| \le 1,000,000$ for each valid i$i$
- the sum of N$N$ over all test cases does not exceed 1,000,000$1,000,000$
- the sum of M$M$ over all test cases does not exceed 5,000$5,000$
- the sum of Q$Q$ over all test cases does not exceed 50,000$50,000$
-----Example Input-----
1
5 3 4
1 1 3
1 2 -4
4 5 2
1 2
1 3
1 1
2 3
-----Example Output-----
3 0 0 4 4
-----Explanation-----
Example case 1:
- The first player will select the 3$3$-rd compo.
- The second and third players will not select any compo.
- The fourth player will select the 1$1$-st, 2$2$-nd and 4$4$-th compos.
- The fifth player will select all the compos.
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 sort_it(array):
new_list = []
for i in range(len(array)):
start = 0
value = array[i][0]
last = len(new_list)
while start != last:
mid = (start + last) // 2
if new_list[mid][0] > value:
last = mid
else:
start = mid+1
new_list.insert(start,array[i])
return new_list
tests = int(input())
for _ in range(tests):
n, m, q = [int(j) for j in input().split()]
challenges = [[0] * 3 for _ in range(m)]
combos = [[0] * 2 for _ in range(q)]
for i in range(m):
challenges[i] = [int(j) for j in input().split()]
for i in range(q):
combos[i] = [int(j) for j in input().split()]
sorted_chalenges = np.zeros((2 * m, 3),dtype=np.intc)
for i in range(m):
sorted_chalenges[2*i] = [challenges[i][0]-1,challenges[i][2],i]
sorted_chalenges[2*i+1] = [challenges[i][1],-challenges[i][2],i]
sorted_chalenges = np.array(sort_it(sorted_chalenges))
types_of_players = np.zeros((m + 1, 2 * m + 1),dtype=np.intc)
player_type = np.zeros(n,dtype=np.intc)
last_player = 0
for i in range(2 * m):
start, value, chal = sorted_chalenges[i]
types_of_players[chal+1:,i+1:] += value
player_type[last_player:start] = i
last_player = start
player_type[last_player:] = 2 * m
combo_types = np.zeros((q, 2 * m + 1),dtype = np.intc)
for i in range(q):
first, last = combos[i]
r, p = [types_of_players[first - 1], types_of_players[last]]
combo_types[i] = np.maximum(p-r,0)
output = np.sum(combo_types,axis=0)[player_type]
for i in range(n):
print(output[i], end = " ")
print("")
``` | {
"language": "python",
"test_cases": [
{
"input": "1\n5 3 4\n1 1 3\n1 2 -4\n4 5 2\n1 2\n1 3\n1 1\n2 3\n",
"output": "3 0 0 4 4\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/CHADAY"
} | vfc_3310 | false | false | false | false | false |
apps | verifiable_code | 1118 | Solve the following coding problem using the programming language python:
Chef is playing a game which contains a binary string.
He can perform one operation only:
- Toggle the i_th bit of the string (0 to 1 or 1 to 0)
By performing operations on the string (can be zero times), you have to convert the string with no adjacent bit being the same.
Can you help chef ?
-----Input:-----
- First line will contain $T$, number of test cases. Then the test cases follow.
- First line of each test case, contains the size of the string $N$
- Seond line contains a single line of input, the binary string.
-----Output:-----
For each testcase, output in a single line answer - the minimum operations.
-----Constraints-----
- $1 \leq T \leq 100$
- $2 \leq |S| \leq 10^3$
-----Sample Input:-----
1
4
1011
-----Sample Output:-----
1
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
'''
Name : Jaymeet Mehta
codechef id :mj_13
Problem : Avenir Strings
'''
from sys import stdin,stdout
test=int(stdin.readline())
for _ in range(test):
N=int(stdin.readline())
seq=list(input())
fp,fp1,fl,fl1=0,0,0,1
for i in range(N):
if fl!=int(seq[i])-0:
fp+=1
fl=1-fl
for i in range(N):
if fl1!=int(seq[i])-0:
fp1+=1
fl1=1-fl1
print(fp) if fp<fp1 else print(fp1)
``` | {
"language": "python",
"test_cases": [
{
"input": "1\n4\n1011\n",
"output": "1\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/ENFE2020/problems/ECFEB205"
} | vfc_3314 | false | false | false | false | false |
apps | verifiable_code | 1119 | Solve the following coding problem using the programming language python:
It's Diwali time and you are on a tour of Codepur, a city consisting of buildings of equal length and breadth because they were designed by a computer architect with a bit of OCD.
The ruling party of Codepur wants to have a blockbuster Diwali celebration but lack enough funds and decided to open a donation channel called Codepur Cares Fund (CCF). So they decided to run a survey.
Each building eihter has permanent donors, whose impact value is represented as a positive integer, or potential donors, whose impact value is represented by negative integers.
Overwhelmed by the response, and sticking to their resource optimized philosophy, they decided to hire you to determine the contiguous buildings which are allowed to donate to CCF with the following rule:
The contiguous buildings / areas with the maximum sum impact shall be allowed for donating to Codepur Cares Fund (CCF).
Help them out to get a stunning Diwali bonus and rest of your trip sponsered!
-----Input:-----
The first line consists of two tab spaced integers m and n, indicating number of rows and columns respectively in the Codepur's city plan (which is a 2-D Matrix).
The next $m$ lines consist of $n$ tab spaced integers $ti$ indicating rows in the matrix.
-----Output:-----
Print the bulidings (represented by their donors numbers) which are eligible to donate to CCF (i.e, have the largest sum contiguously) as a 2-D matrix with the elements being tab-spaced.
-----Constraints-----
- $0 \leq m,n \leq 10^{15}$
- $-10^{15} \leq ti \leq 10^5$
-----Sample Input:-----
6 5
0 -2 -7 0 -1
9 2 -6 2 0
-4 1 -4 1 0
-1 8 0 -2 1
-10 1 1 -5 6
-15 -1 1 5 -4
-----Sample Output:-----
9 2
-4 1
-1 8
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
#dt = {} for i in x: dt[i] = dt.get(i,0)+1
import sys;input = sys.stdin.readline
inp,ip = lambda :int(input()),lambda :[int(w) for w in input().split()]
def kadane(arr, start, finish, n):
Sum = 0
maxSum = float('-inf')
i = None
finish[0] = -1
local_start = 0
for i in range(n):
Sum += arr[i]
if Sum < 0:
Sum = 0
local_start = i + 1
elif Sum > maxSum:
maxSum = Sum
start[0] = local_start
finish[0] = i
if finish[0] != -1:
return maxSum
maxSum = arr[0]
start[0] = finish[0] = 0
for i in range(1, n):
if arr[i] > maxSum:
maxSum = arr[i]
start[0] = finish[0] = i
return maxSum
def findMaxSum(M):
nonlocal ROW, COL
maxSum, finalLeft = float('-inf'), None
finalRight, finalTop, finalBottom = None, None, None
left, right, i = None, None, None
temp = [None] * ROW
Sum = 0
start = [0]
finish = [0]
for left in range(COL):
temp = [0] * ROW
for right in range(left, COL):
for i in range(ROW):
temp[i] += M[i][right]
Sum = kadane(temp, start, finish, ROW)
if Sum > maxSum:
maxSum = Sum
finalLeft = left
finalRight = right
finalTop = start[0]
finalBottom = finish[0]
for i in range(finalTop,finalBottom+1):
print(*M[i][finalLeft:finalRight+1])
ROW,COL = ip()
M = [ip() for i in range(ROW)]
findMaxSum(M)
``` | {
"language": "python",
"test_cases": [
{
"input": "6 5\n0 -2 -7 0 -1\n9 2 -6 2 0\n-4 1 -4 1 0\n-1 8 0 -2 1\n-10 1 1 -5 6\n-15 -1 1 5 -4\n",
"output": "9 2\n-4 1\n-1 8\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/CHLG2020/problems/CCFUND"
} | vfc_3318 | false | false | false | false | false |
apps | verifiable_code | 1120 | Solve the following coding problem using the programming language python:
Due to the COVID pandemic, maintaining social distancing is of utmost importance. In this problem, you'd calculate how many days would it take to reach an apocalypse from an initial case if nobody maintains social distancing.
The Earth is flat (for this question) and it's dimensions are $R$ x $C$
The whole Earth is already divided into blocks and the virus can spread in all directions except diagonally. The virus from each newly infected person will spread in all directions in the next day, thus growing exponentially.
-----Input:-----
- First line will contain $T$, number of testcases. Then the testcases follow.
- Next line contains $R$ and $C$ respectively separated by a space.
- Next line contains $x$ and $y$ respectively separated by a space, denoting the indices of the initial case in the world.
-----Output:-----
For each testcase, output in a single line an integer denoting the number of days after which everyone will be infected.
-----Constraints-----
- $1 \leq T \leq 10^4$
- $2 \leq R,C \leq 10^7$
- $0 \leq x,y \leq 10^7$
-----Subtasks-----
- 10 points : $1 \leq T \leq 5$ and $2 \leq R,C \leq 10$
- 20 points : $2 \leq R,C \leq 10^5$
- 70 points : Original constraints
-----Sample Input:-----
2
4 5
2 1
3 4
1 1
-----Sample Output:-----
5
3
-----EXPLANATION:-----
2nd test case:
Assuming, it's a small world of $3$ x $4$
0 is not infected. 1 is infected.
World indexing is like a 2D array:
(0,0) (0,1) (0,2) (0,3)
(1,0) (1,1) (1,2) (1,3)
(2,0) (2,1) (2,2) (2,3)
If this is the case on Day 0:
0 0 0 0
0 1 0 0
0 0 0 0
This will be the case on Day 1:
0 1 0 0
1 1 1 0
0 1 0 0
This will be the case on Day 2:
1 1 1 0
1 1 1 1
1 1 1 0
The End on Day 3:
1 1 1 1
1 1 1 1
1 1 1 1
Thus, answer will be 3
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
#AUTHOR:: AMAN VERMA
try:
for _ in range(int(input())):
row,column=list(map(int,input().split(" ")))
x_x,y_y=list(map(int,input().split(" ")))
ab=max((x_x-0),(row-x_x-1))
ba=max((y_y-0),(column-y_y-1))
print(ab+ba)
except:
pass
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n4 5\n2 1\n3 4\n1 1\n",
"output": "5\n3\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/QTST2020/problems/APCLYPSE"
} | vfc_3322 | false | false | false | false | true |
apps | verifiable_code | 1121 | Solve the following coding problem using the programming language python:
Chef is stuck on the minute hand of a giant clock. To escape from this clock he needs to get onto the hour hand which has an exit door.
Since the minute hand and and hour hand are not connected at any point, chef will surely need to make a jump. Since he wants minimum risks, he chooses to jump on the hour hand so that the angle he has to cover is minimum possible.
You will be given a clock time in $UTC$ format denoting time of chef's jump and you have to compute the minimum angle that chef needs to cover while completing the jump.
For some reason chef times his jump only when the number of minutes is a multiple of 5.
-----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 string denoting time in UTC format (e.g. 10:20 i.e. 10 hours and 20 minutes)
-----Output-----
For each test case, print a single line denoting the smallest angle of jump.
-----Constraints-----
- $1 \leq T \leq 10^3$
- $0 \leq hours \leq 23$
- $0 \leq minutes \leq 59$
-----Example Input-----
3
14:20
02:10
09:30
-----Example Output-----
50 degree
5 degree
105 degree
-----Explanation-----
- In the second case, once the hour hand reaches 2 it starts moving towards 3 with the passing of every minute, hence when the minute hand points 10 minutes, the hour hand has already covered some angle towards 3.
In this scenario the two angles made by hour and minute hand are 355 and 5 degrees. Since chef will jump on the side with minimum angle, he chooses the one with 5-degree angle.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
# cook your dish here
t=int(input())
while t>0:
a=input().split(":")
a1=int(a[0])
a2=int(a[1])
b1=a1%12
if a2%5!=0:
b2=(a2//5)*5+5
else:
b2=a2
c1=b1*30
extra=0.5*b2
c1+=extra
c1%=360
d1=(b2//5)*30
d1%=360
if c1>d1:
ans1=c1-d1
ans2=360-ans1
else:
ans1=d1-c1
ans2=360-ans1
ans=min(ans1,ans2)
if ans==int(ans):
ans3=int(ans)
y=str(ans3)+" degree"
print(y)
else:
y=str(ans)+" degree"
print(y)
t-=1
``` | {
"language": "python",
"test_cases": [
{
"input": "3\n14:20\n02:10\n09:30\n",
"output": "50 degree\n5 degree\n105 degree\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/PAHC2020/problems/CHEFJUMP"
} | vfc_3326 | false | false | false | false | false |
apps | verifiable_code | 1122 | Solve the following coding problem using the programming language python:
Ravi is very good student in mathematics and he also like Even numbers very much .
On the other hand his friend Jhon like Odd numbers . Both of them are preparing for IIT JEE Advance .One day they are solving a question together the question was Find the sum of first $n$ terms of the given series $1^2+2.2^2+3^2+2.4^2+5^2+2.6^2+...........$
If the sum is odd then Jhon will be happy and will solve 2 more questions,and Ravi will not attempt more questions. If sum is even Ravi will be happy and will solve 2 more questions and Jhon will not attempt more questions.
So Your task is to decide who will solve more questions.
-----Input:-----
- First line will contain $n$, number of terms in the given series.
-----Output:-----
Output single line "Ravi" if he solve more questions or "Jhon" if he solve more questions.
-----Constraints-----
- $1 \leq n \leq 100$
-----Sample Input:-----
2
3
-----Sample Output:-----
Jhon
Ravi
-----EXPLANATION:-----
In the first test cases sum of 2 terms is 9 (according to the given series) which is an odd number so Jhon will solve 2 more questions and Ravi will not attempt more questions.
In second test case sum of 3 terms is 18 (according to the given series) which is an even number according to the given series so Ravi will solve 3 more questions and Jhon will not attempt more questions.
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
while True:
try:
m=int(input())
n=int(m/2)
a=m-n
sum_even= int(2*(2*n*(n+1)*(2*n+1))/3)
sum_odd= int(((4*a*a*a)-a)/3)
result=sum_odd+sum_even
if result%2==0:
print('Ravi')
else:
print('Jhon')
except:
break;
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n3\n",
"output": "Jhon\nRavi\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/CFUN2020/problems/CODSTAN7"
} | vfc_3330 | false | false | false | false | false |
apps | verifiable_code | 1123 | Solve the following coding problem using the programming language python:
Chef has decided to start home delivery from his restaurant. He hopes that he will get a lot of orders for delivery, however there is a concern. He doesn't have enough work forces for all the deliveries. For this he has came up with an idea - he will group together all those orders which have to be delivered in nearby areas.
In particular, he has identified certain bidirectional roads which he calls as fast roads. They are short and usually traffic free, so the fast travel is possible along these roads. His plan is that he will send orders to locations A and B together if and only if it is possible to travel between A and B using only fast roads. Your task is, given the configuration of fast roads, identify which orders are to be sent together.
-----Input-----
First line of input contains an integer T, the number of test cases. Then T test cases follow. First line of each test case contains two space separated integers N and M, denoting number of locations and the number of fast roads. Then M lines follow each containing two space separated integers A and B, denoting that there is a fast road between locations A and B. Assume that locations are indexed by numbers from 0 to N-1.
Next line contains an integer Q denoting the number of queries. Each of the next Q lines contain two integers X and Y. For each query you have to find out if orders meant for locations X and Y are to be sent together or not.
Note that there might be multiple fast roads between same pair of locations, also there might be a fast road that links a location to itself.
-----Output-----
For each test case print Q lines - one for each query. Output "YO" if the orders are to be
delivered together and "NO" otherwise (quotes for clarity).
-----Constraints-----
1 ≤ T ≤ 100
1 ≤ N ≤ 100
1 ≤ M ≤ 1000
0 ≤ A, B, X, Y ≤ N-1
1 ≤ Q ≤ 3000
-----Example-----
Input:
1
4 2
0 1
1 2
3
0 2
0 3
2 1
Output:
YO
NO
YO
-----Warning!-----
There are large input and output files in this problem. Make sure you use fast enough I/O methods.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
# cook your dish here
from sys import stdin, stdout
from math import ceil
def solve():
for _ in range(int(input())):
n, m = map(int, stdin.readline().split())
par = [i for i in range(n)]
for i in range(m):
ta, tb = map(int, stdin.readline().strip().split())
a, b = min(ta, tb), max(ta, tb)
for j in range(n):
if par[j] == par[b] and j != b:
par[j] = par[a]
par[b] = par[a]
q = int(input())
while q:
q -= 1
x, y = map(int, stdin.readline().split())
if par[x] == par[y]:
print("YO")
else:
print("NO")
def __starting_point():
solve()
__starting_point()
``` | {
"language": "python",
"test_cases": [
{
"input": "1\n4 2\n0 1\n1 2\n3\n0 2\n0 3\n2 1\n\n\n",
"output": "YO\nNO\nYO\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/HDELIVER"
} | vfc_3334 | false | false | false | false | false |
apps | verifiable_code | 1124 | Solve the following coding problem using the programming language python:
Lumpy is a bus driver. Today, the conductor is absent so Lumpy has to do the conductor's job as well. There are N creatures in the bus. Sometimes the creatures don't carry change and can't pay the exact amount of the fare. Each creature in the bus today has paid an amount
greater than his/her fare. You are given information about the extra amount paid by each creature, by an array A of size N, where Ai denotes the extra amount paid by the i-th creature, in rupees.
After the end of the trip, Lumpy noticed that he had P one rupee coins and Q two rupee coins. He wants to pay back the creatures using this money. Being a kind hearted moose, Lumpy wants to pay back as many creatures as he can. Note that Lumpy will
not pay back the i-th creature if he can't pay the exact amount that the i-th creature requires with the coins that he possesses.
Lumpy is busy driving the bus and doesn't want to calculate the maximum number of creatures he can satisfy - He will surely cause an accident if he tries to do so. Can you help him out with this task?
-----Input-----
- The first line of the input contains an integer T denoting the number of test cases. The description of T test cases follows.
- For each test case, first line consists of three space separated integers N, P and Q.
- Second line consists of N space separated integers A containing N space integers, where i-th integer denotes Ai.
-----Output-----
- For each test case, output a single line containing an integer corresponding to maximum number of creatures that Lumpy can pay back.
-----Constraints-----
- 1 ≤ T ≤ 106
- 1 ≤ N ≤ 105
- 1 ≤ Ai ≤ 109
- 0 ≤ P, Q ≤ 1014
- Sum of N over all the cases does not exceed 106
-----Subtasks-----
- Subtask #1 (15 points): P = 0
- Subtask #2 (15 points): Q = 0
- Subtask #3 (70 points): Original constraints
-----Example-----
Input:3
3 3 0
1 2 2
3 2 1
1 2 1
4 5 4
2 3 4 5
Output:2
3
3
-----Explanation-----
Example 1. Lumpy has just 3 one rupee coins.
He can pay creatures numbered {1, 2} or creatures numbered {1, 3} with these coins. Thus, answer is 2.
Example 2. Lumpy has 2 one rupee coins and 1 two rupee coin.
In the optimal solution, Lumpy can give the two rupee coin to creature 2 and the one rupee coins to creatures 1 and 3. Thus, answer is 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
# cook your dish here
t=int(input())
for _ in range(t):
n,p,q=list(map(int,input().split(" ")))
l=list(map(int,input().split(" ")))
l.sort()
s=sum(l)
a=p+2*q
b=0
for i in l:
if(p==0):
if(i%2==0 and a>=i):
a=a-i
b=b+1
elif(q==0):
if(a>=i):
a=a-i
b=b+1
else:
if(i%2==0 and a>=i):
a=a-i
b=b+1
elif(i%2!=0 and p!=0 and a>=i):
a=a-i
b=b+1
p=p-1
print(b)
``` | {
"language": "python",
"test_cases": [
{
"input": "3\n3 3 0\n1 2 2\n3 2 1\n1 2 1\n4 5 4\n2 3 4 5\n",
"output": "2\n3\n3\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/LUMPYBUS"
} | vfc_3338 | false | false | false | false | false |
apps | verifiable_code | 1125 | Solve the following coding problem using the programming language python:
You are the principal of the Cake school in chefland and today is your birthday. You want to treat each of the children with a small cupcake which is made by you. But there is a problem, You don't know how many students are present today.
The students have gathered of the morning assembly in $R$ rows and $C$ columns. Now you have to calculate how many cakes you have to make such that each child gets a cupcake.
-----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, two integers $R$ and $C$.
-----Output:-----
For each test case, output number of cupcakes you have to make.
-----Constraints-----
- $1 \leq T \leq 1000$
- $2 \leq R,C \leq 10^6$
-----Sample Input:-----
1
5 10
-----Sample Output:-----
50
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=list(map(int,input().split()))
print(n[0]*n[1])
``` | {
"language": "python",
"test_cases": [
{
"input": "1\n5 10\n",
"output": "50\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/ENDE2020/problems/ENCDEC2"
} | vfc_3342 | false | false | false | false | false |
apps | verifiable_code | 1126 | Solve the following coding problem using the programming language python:
"How did you get the deal,how did he agree?"
"Its's simple Tom I just made him an offer he couldn't refuse"
Ayush is the owner of a big construction company and a close aide of Don Vito The Godfather, recently with the help of the Godfather his company has been assigned a big contract according to the contract he has to make n number of V shaped infinitely long roads(two V shaped roads may or not intersect) on an infinitely large field.
Now the company assigning the contract needs to know the maximum number of regions they can get after making n such roads.
Help Ayush by answering the above question.
-----Input:-----
- The first line consists of the number of test cases $T$.
- Next T lines consists of the number of V shaped roads $n$.
-----Output:-----
For each test case print a single line consisting of the maximum regions obtained.
-----Constraints-----
- $1 \leq T \leq 10$
- $1 \leq n \leq 10^9$
-----Sample Input:-----
2
1
2
-----Sample Output:-----
2
7
-----EXPLANATION:-----
Test case 1: For one V shaped road there will be 2 regions
Test case 2: For n=2 the following figure depicts the case of maximum regions:
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())
print((2*(pow(n,2)))-n+1)
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n1\n2\n",
"output": "2\n7\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/CFW32020/problems/AYUSCRT"
} | vfc_3346 | false | false | false | false | false |
apps | verifiable_code | 1127 | Solve the following coding problem using the programming language python:
Nitika was once reading a history book and wanted to analyze it. So she asked her brother to create a list of names of the various famous personalities in the book. Her brother gave Nitika the list. Nitika was furious when she saw the list. The names of the people were not properly formatted. She doesn't like this and would like to properly format it.
A name can have at most three parts: first name, middle name and last name. It will have at least one part. The last name is always present. The rules of formatting a name are very simple:
- Only the first letter of each part of the name should be capital.
- All the parts of the name except the last part should be represented by only two characters. The first character should be the first letter of the part and should be capitalized. The second character should be ".".
Let us look at some examples of formatting according to these rules:
- gandhi -> Gandhi
- mahatma gandhI -> M. Gandhi
- Mohndas KaramChand ganDhi -> M. K. Gandhi
-----Input-----
The first line of the input contains an integer T denoting the number of test cases.
The only line of each test case contains the space separated parts of the name.
-----Output-----
For each case, output the properly formatted name.
-----Constraints-----
- 1 ≤ T ≤ 100
- 2 ≤ Length of each part of the name ≤ 10
- Each part of the name contains the letters from lower and upper case English alphabets (i.e. from 'a' to 'z', or 'A' to 'Z')
-----Subtasks-----
Subtask #1 (40 points)
- There is exactly one part in the name.
Subtask #2 (60 points)
- Original constraints.
-----Example-----
Input:
3
gandhi
mahatma gandhI
Mohndas KaramChand gandhi
Output:
Gandhi
M. Gandhi
M. K. Gandhi
-----Explanation-----
The examples are already explained in the problem statement.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
# cook your dish here
x= int(input())
for i in range(x):
y = list(map(str, input().split()))
j= 0
while j<len(y)-1:
print((y[j][0]).capitalize()+".", end=' ')
j+= 1
print(y[len(y)-1].capitalize())
``` | {
"language": "python",
"test_cases": [
{
"input": "3\ngandhi\nmahatma gandhI\nMohndas KaramChand gandhi\n\n\n",
"output": "Gandhi \nM. Gandhi \nM. K. Gandhi \n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/NITIKA"
} | vfc_3350 | false | false | false | false | false |
apps | verifiable_code | 1128 | Solve the following coding problem using the programming language python:
The Chef is given an array of numbers and asked to find the first balance point of an array. A balance point is an index in the array N where the sum of the integers to the left of N is equal to the sum of the integers to the right of N. If there is no such balance point, print -1
-----Input-----
The first line of the input contains an integer T denoting the number of test cases. The description of T test cases follows.
The first line of each test case contains a single integer N denoting the number of weights on the array. The second line contains N space-separated integers A1, A2, ..., AN denoting the weights
-----Output-----
For each test case, output a single line containing the index of the first balance point. If no such index exists, output -1
-----Constraints-----
For Subtask 1:
- 1 ≤ T ≤ 10
- 1 ≤ N ≤ 10
- -1000 ≤ A1, A2, ..., AN ≤ 1000
For Subtask 1:
- 1 ≤ T ≤ 10
- 1 ≤ N ≤ 1000
- -10000 ≤ A1, A2, ..., AN ≤ 10000
-----Example-----
Input:
2
7
7 8 9 1 9 8 7
6
1 100 50 -51 1 1
Output:
3
1
-----Explanation-----
Example case 1. In the first case, at the midpoint of the array 1, the sum of the left side {7,8,9} is equal to the sum of the right side {9,8,7}
Example case 1. In the second case, at index 1, the sum of left side =1 is equal to the sum of the right side {50,-51,1,1}
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
import sys
t = eval(input())
for j in range(t):
n = eval(input())
a = list(map(int, input().split()))
ch = 0
sm = 0 ; x = sum(a)
s1 = [0] * n ; s2 = [0] * n
for i in range(n):
sm += a[i]
s1[i] = sm
s2[i] = x
x -= a[i]
if(sum(a) - a[0] == 0):
print(0)
elif(sum(a) - a[n - 1] == 0):
print(n - 1)
else:
for i in range(1, n - 1):
if(s1[i - 1] == s2[i + 1]):
print(i)
ch = 1
break
if(ch == 0):
if(n == 1):
print(0)
else:
print(-1)
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n7\n7 8 9 1 9 8 7\n6\n1 100 50 -51 1 1\n",
"output": "3\n1\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/TSCO2017/problems/TSECJ101"
} | vfc_3354 | false | false | false | false | false |
apps | verifiable_code | 1129 | Solve the following coding problem using the programming language python:
Chef’s girlfriend is angry with him because he forgot her birthday. Chef decided to please her by gifting her a Love Graph.
Chef has $N$ vertices: $V_1, V_2, \dots, V_N$. Love Graph is an undirected multigraph with no self-loops and can be constructed by performing the following operations:-
- Choose an integer $i$ ($1 \leq i \leq N$)
- Choose another integer $j \space \space \{ (i \neq j) \text{ and } (1 \leq j \leq N) \}$
- Make an edge between $V_i$ and $V_j$
- Set $i = j$
- Repeat steps $2, 3$ and $4$ in order $M-1$ more times.
Find the number of ways in which Chef can construct a Love Graph. Since the answer can be very large, compute it modulo $10^9+7$.
-----Input-----
- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
- The first line of each test case contains two space-separated integers $N$ and $M$.
-----Output-----
For each test case, print a single line containing one integer — the number of ways in which Chef can construct a Love Graph modulo $10^9+7$.
-----Constraints-----
- $1 \leq T \leq 10^5$
- $2 \leq N \leq 10^9$
- $1 \leq M \leq 10^{18}$
-----Subtasks-----
- 30 points:
- $1 \leq T \leq 100$
- $2 \leq N \leq 10$
- $1 \leq M \leq 10$
- 70 points: original constraints
-----Sample Input-----
1
2 1
-----Sample Output-----
2
-----Explanation-----
There are two ways of constructing Love Graph.
In first way, we pick Vertex 1 and then join with Vertex 2.
In second way, we pick Vertex 2 and then join with Vertex 1.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
def fastpow(base, power):
result = 1
while power > 0:
if power % 2 == 0:
power = power // 2
base = base * base
else:
power = power - 1
result = result * base
power = power // 2
base = base * base
return result
t=int(input())
for i in range(t):
a=list(map(int,input().split()))
n,r=a[0],a[1]
w=(n*(fastpow(n-1,r)))%((10**9)+7)
print(w)
``` | {
"language": "python",
"test_cases": [
{
"input": "1\n2 1\n",
"output": "2\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/DCC2020/problems/DCC201"
} | vfc_3358 | false | false | false | false | false |
apps | verifiable_code | 1130 | Solve the following coding problem using the programming language python:
Finally, a COVID vaccine is out on the market and the Chefland government has asked you to form a plan to distribute it to the public as soon as possible. There are a total of $N$ people with ages $a_1, a_2, \ldots, a_N$.
There is only one hospital where vaccination is done and it is only possible to vaccinate up to $D$ people per day. Anyone whose age is $\ge 80$ or $\le 9$ is considered to be at risk. On each day, you may not vaccinate both a person who is at risk and a person who is not at risk. Find the smallest number of days needed to vaccinate everyone.
-----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 $D$.
- 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 smallest required number of days.
-----Constraints-----
- $1 \le T \le 10$
- $1 \le N \le 10^4$
- $1 \le D \le 10^5$
- $1 \le a_i \le 100$ for each valid $i$
-----Subtasks-----
Subtask #1 (100 points): original constraints
-----Example Input-----
2
10 1
10 20 30 40 50 60 90 80 100 1
5 2
9 80 27 72 79
-----Example Output-----
10
3
-----Explanation-----
Example case 1: We do not need to worry about how the people are grouped, since only one person can be vaccinated in a single day. We require as many days as there are people.
Example case 2: There are two people at risk and three people who are not at risk. One optimal strategy is to vaccinate the two people at risk on day $1$ and the remaining three on the next $2$ days.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
for _ in range(int(input())):
f,d=list(map(int,input().split()))
arr=list(map(int,input().split()))
risk=0
days_risk=0
days_norm=0
if d==1:
print(f)
else:
for a in arr:
if a>=80 or a<=9:
risk+=1
norm=f-risk
if risk%d==0:
days_risk=risk//d
else:
days_risk=(risk//d)+1
if norm%d==0:
days_norm=norm//d
else:
days_norm=(norm//d)+1
print(days_risk+days_norm)
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n10 1\n10 20 30 40 50 60 90 80 100 1\n5 2\n9 80 27 72 79\n",
"output": "10\n3\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/VACCINE2"
} | vfc_3362 | false | false | false | false | false |
apps | verifiable_code | 1131 | Solve the following coding problem using the programming language python:
Chef has an array of N natural numbers most of them are repeated. Cheffina challenges chef to find all numbers(in ascending order) whose frequency is strictly more than K.
-----Input:-----
- First-line will contain $T$, the number of test cases. Then the test cases follow.
- Each test case contains two lines of input, two integers $N, K$.
- N space-separated natural numbers.
-----Output:-----
For each test case, output in a single line answer.
-----Constraints-----
- $1 \leq T \leq 10$
- $1 \leq N, K \leq 10^5$
- $1 \leq arr[i] \leq 10^5$
-----Sample Input:-----
1
5 1
5 2 1 2 5
-----Sample Output:-----
2 5
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=[int(x) for x in input().split()]
a=list(map(int,input().split()))
dp=[0]*(max(a)+1)
for _ in range(n):
dp[a[_]]+=1
for _ in range(1,len(dp)):
if dp[_]>k:
print(_,end=" ")
print()
``` | {
"language": "python",
"test_cases": [
{
"input": "1\n5 1\n5 2 1 2 5\n",
"output": "2 5\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/PEND2020/problems/ANITGUY8"
} | vfc_3366 | false | false | false | false | false |
apps | verifiable_code | 1132 | Solve the following coding problem using the programming language python:
Shaun was given $N$ pairs of parenthesis ( ) by his teacher who gave him a difficult task.The task consists of two steps. First,Shaun should colour all $N$ pairs of parenthesis each with different color but opening and closing bracket of a particular pair should be of same colour. Then,Shaun should report to his teacher the number of ways he can arrange all $2*N$ brackets such that sequence form is valid. Teacher defined valid sequence by these rules:
- Any left parenthesis '(' must have a corresponding right parenthesis ')'.
- Any right parenthesis ')' must have a corresponding left parenthesis '('.
- Left parenthesis '(' must go before the corresponding right parenthesis ')'.
Note: Shaun could match opening and closing brackets of different colours.
Since number of ways can be large, Shaun would report the answer as modulo 1000000007 ($10^9 + 7$).
-----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 answer given by Shaun to his teacher modulo 1000000007.
-----Constraints-----
- $1 \leq T \leq 100000$
- $1 \leq N \leq 100000$
-----Sample Input:-----
3
1
2
3
-----Sample Output:-----
1
6
90
-----EXPLANATION:-----
Here numbers from $1$ to $N$ have been used to denote parenthesis.A unique number corresponds to a unique pair of parenthesis.
-In the first test case , you can use only one color to color the parenthesis you could arrange it only in one way i.e, 1 1
-In the second test case you can use two colors and the possible ways of arranging it are
1 1 2 2
1 2 2 1
1 2 1 2
2 2 1 1
2 1 1 2
2 1 2 1
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
mod = 1000000007
fac = [1,1]
maxn = (10**5)+5
for i in range(2,maxn):
x = (fac[-1]*i)%mod
fac.append(x)
pre = [1]
for i in range(2,maxn):
x = 2*i-1
x = (pre[-1]*x)%mod
pre.append(x)
for _ in range(int(input())):
n = int(input())
x = fac[n]
y = pre[n-1]
print((x*y)%mod)
``` | {
"language": "python",
"test_cases": [
{
"input": "3\n1\n2\n3\n",
"output": "1\n6\n90\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/COCA2020/problems/COCA2003"
} | vfc_3370 | false | false | false | false | true |
apps | verifiable_code | 1133 | Solve the following coding problem using the programming language python:
Shivam is working on electric circuits. He requires some connecting wires. He needs to make a total of N connections and he has mentioned his wire length requirements for each connection in an integer sequence A. For buying wires, he need to decide the length of each wire piece, and he’ll get as many wire pieces of the chosen length each at unit cost (cost 1 per piece) but he can't get wires of different lengths. Also, he can't cut wire pieces to make new pieces of different (smaller) length(s).
But he can connect any number of wires together to form a new single wire piece whose length is the sum of lengths of the wires connected. So, Shivam needs to choose an integer length for buying wires. Shivam hates to waste anything, and he hates it even more if that thing is money.
Shivam is weak in mathematics and is asking you to help him in this situation. Help him decide the length of wires and total number of wires so as to minimize the total expenditure.
Note: You cannot make a connection which requires a wire piece of length X with a wire piece of length Y if X≠Y.
Input:
· The first line of the input contains T = Number of Test cases
· The first line of each test case contains an integer N
· The second line contains N space separated integers A1, A2, …., AN.
Output:
For each test case print a single line containing two space separated integers, length of each wire and the corresponding minimum cost.
Constraints:
· 1 <= T <= 10
· 1 <= N <= 10^5
· 1 <= Ai <= 10^5, for each valid i
Sample Input:
1
3
2 4 8
Sample Output:
2 7
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
from sys import stdin,stdout
from math import gcd
nmbr=lambda:int(stdin.readline())
lst=lambda:list(map(int, stdin.readline().split()))
for _ in range(nmbr()):
n=nmbr()
a=lst()
g=a[0]
ans=0
for v in a[1:]:
g=gcd(v,g)
for i in a:
ans+=i//g
print(g,ans)
``` | {
"language": "python",
"test_cases": [
{
"input": "1\n3\n2 4 8\n",
"output": "2 7\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/CSTR2020/problems/ELECTRIC"
} | vfc_3374 | false | false | false | false | false |
apps | verifiable_code | 1134 | Solve the following coding problem using the programming language python:
Daenerys Targaryen has been suggested by her counselors to leave the Meereen and start conquering other parts of the world. But she knows giving up on the people of Meereen means victory of slavery. Her plan is to start conquering rest of the world while she remains in Meereen. She can only trust her bravest and most beloved Daario Naharis to undertake this risk. She asks him to conquer a few nations and promises him a help from her dragons. She also promises to marry him if he successfully conquers all the nations and not if he is defeated.
Daario has to conquer 'N' number of nations each nation with army size A[i]. He attacks the nations serially. As promised, he gets help from Daenerys's Dragons. His first 'M' attacks are made with the help of Dragons.
For first 'M' attacks, he gains A[i] soldiers.
For the rest, he looses ceiling of A[i]/2 soldiers.
He is defeated if he is left with no army before he conquers all the 'N' nations. He has no army initially and only has Dragons.
-----Input-----
First line has 'T' which is the number of test cases.
For each test cases there are two space separated integers 'N' and 'M' denoting the number of nations and the number of nations he has Dragon's help for respectively.
Follows N space separated integers denoting the size of army of each nation.
-----Output-----
Print 'VICTORY' if Daario conquers all nations and 'DEFEAT' if he doesn't.
-----Constraints-----
- 1 ≤ T ≤ 500
- 1 ≤ M ≤N ≤ 100000
- 1 ≤ A[i] ≤ 100000
-----Example-----
Input:
3
5 3
1 2 3 4 5
6 2
4 4 4 4 4 4
7 4
10 10 10 10 50 60 70
Output:
VICTORY
VICTORY
DEFEAT
-----Explanation-----
Example case 1.
First 3 attacks add 1,2,3 to his army making it 6. (1+2+3 = 6)
Then he looses 2 and 3 making it 1. (6-2-3 = 1)
He conquers all so VICTORY.
Example case 2.
First 2 attacks add 4,4 to his army making it 8. (4+4 = 8)
Then he looses 2,2,2,2 making it 0. (8-2-2-2-2 = 0)
He conquers all so VICTORY.
Example case 3.
First 4 attacks add 10,10,10,10 to his army making it 40. (10+10+10+10 = 40)
Then he looses 25 and then all 15 out of possible 30 making it 0. (40-25-15 = 0)
He is defeated on 6th attack so DEFEAT.
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()))
a=list(map(int,input().split()))
army=0
if n>m:
for i in range(0,m):
army+=a[i]
for j in range(m,n):
army=army-(a[j]/2)
if army<0:
print('DEFEAT')
break
else:
continue
else:
print('VICTORY')
if n<=m:
print('VICTORY')
``` | {
"language": "python",
"test_cases": [
{
"input": "3\n5 3\n1 2 3 4 5\n6 2\n4 4 4 4 4 4\n7 4\n10 10 10 10 50 60 70\n",
"output": "VICTORY\nVICTORY\nDEFEAT\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/KOKT2015/problems/KOKT03"
} | vfc_3378 | false | false | false | false | false |
apps | verifiable_code | 1135 | Solve the following coding problem using the programming language python:
Chef Ada is the FootBall coach of the Dinosaurs Institute of Technology.
There are $N$ dinosaurs (enumerated $1$ through $N$) placed in a line. The i-th dinosaur has a height of $i$ meters.
Ada is training The dinosaurs in the following tactic:
- Initially the leftmost dinosaur has the ball.
- The dinosaur that has the ball passes the ball to the nearest dinosaur to the right that is tallest than him.
- The previous step continues until the ball reaches the tallest dinosaur, then he throws the ball and scores a goal!
Help Ada reordering the dinosaurs in such a way that the ball is passed from dinosaur to dinosaur exactly $K$ times.
For example, if there are $5$ dinosaurs ordered as $[2,3,1,5,4]$, then the ball goes $2 \rightarrow 3\rightarrow5 \rightarrow goal$, and the ball was passed two times.
-----Input:-----
- First line will contain $T$, number of testcases.
- Each test case consist of a line with two space separated integers $N,K$.
-----Output:-----
For each testcase, output in a single line conaining $N$ integers representing one possible ordering in which the dinosaurs can be placed.
-----Constraints-----
- $1 \leq T \leq 2^8$
- $2 \leq N \leq 20$
- $0 \leq K \leq N-1$
-----Sample Input:-----
1
5 2
-----Sample Output:-----
2 3 1 5 4
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
# cook your dish here
t=int(input())
while t!=0:
n,k=map(int,input().split())
lst=[]
for i in range(1,n+1):
lst.append(i)
lst[k],lst[n-1]=lst[n-1],lst[k]
for item in lst:
print(item,end=' ')
t-=1
``` | {
"language": "python",
"test_cases": [
{
"input": "1\n5 2\n",
"output": "2 3 1 5 4\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/MXCH"
} | vfc_3382 | false | false | false | false | false |
apps | verifiable_code | 1136 | Solve the following coding problem using the programming language python:
Chef has N laddus of K sweetness each. Chef wants to eat all laddus, but Chef is restricted with the given condition that he must not eat two adjacent laddus. Chef starts calculating the maximum sweetness that he will get from the laddus. Find the maximum sweetness that chef gets at the end of all calculations.
-----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, two integers $N, K$.
-----Output:-----
For each test case, output in a single line answer as Maximum sweetness the chef will have.
-----Constraints-----
- $1 \leq T \leq 10^5$
- $1 \leq N \leq 10^5$
- $1 \leq K \leq 10^5$
-----Sample Input:-----
2
1 2
4 3
-----Sample Output:-----
2
6
-----EXPLANATION:-----
For 1) Chef will get only 1 laddu with sweetness 2.
For 2) Chef will have multiple ways as
[1,3], [2,4], [1,4] with sweetness 6
[1],[2],[3],[4] with sweetness 3.
Maximum sweetness will be 6.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
t = int(input())
for _ in range(t):
n,m = map(int,input().split())
if n==1:
print(m)
else:
if n%2==0:
print((n//2)*m)
else:
print(((n//2)+1)*m)
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n1 2\n4 3\n",
"output": "2\n6\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/PBK12020/problems/ITGUY17"
} | vfc_3386 | false | false | false | false | false |
apps | verifiable_code | 1137 | Solve the following coding problem using the programming language python:
Vishal Wants to buy 2 gifts for his best friend whose name is Annabelle(her age is 20), So they both went for shopping in a store. But Annabelle gave, Vishal a condition that she will accept this gifts only when the total price of the gifts is the same as her age times 100.
The store contains, a list of items whose prices are also displayed, Now Vishal is asking for your help to buy gifts, as he wants to impress Annabelle this time.
Note: Vishal cannot buy the same item more than once.
-----Input:-----
- The first line of the input contains a single integer $T$. $T$ denoting the number of test cases. The description of $T$ test cases is as follows.
- The next line of the input contains a single integer $N$. $N$ denotes the total number of items in store.
- The next line of the input contains $N$ space-separated integers $A1, A2, A3...An$ where $ith$ number denotes the price of $ith$ element.
-----Output:-----
- For each test-case print "Accepted"(without quotes) if the gifts are accepted by Annabelle, else print "Rejected"(without quotes)
-----Constraints:-----
- $1 \leq T \leq 10^3$
- $1 \leq N \leq 10^5$
- $1 \leq A1, A2, A3...An \leq 10^7$
-----Sample Input:-----
1
5
10 2 1000 50 1000
-----Sample Output:-----
Accepted
-----Explanation:-----
- As the given list of items have 2 items whose price sum up to the age times 100 of Annabelle i.e. 1000+1000 = (20 *100)
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
test = int(input())
ANS = list()
for i in range(test):
n = int(input())
items = sorted(list(map(int, input().split())))
c = 1
for j in range(len(items)):
if items[j] < 2000:
t = 2000 - items[j]
if t in items[j+1:]:
ANS.append("Accepted")
c = 2
break
else:
pass
else:
break
if c==1:
ANS.append("Rejected")
for ans in ANS:
print(ans)
``` | {
"language": "python",
"test_cases": [
{
"input": "1\n5\n10 2 1000 50 1000\n",
"output": "Accepted\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/ARYS2020/problems/BDYGFT"
} | vfc_3390 | false | false | false | false | false |
apps | verifiable_code | 1138 | Solve the following coding problem using the programming language python:
Sereja is hosting his birthday dinner. He invited his N close friends. Let us number the people from 1 to N according to the order in which they arrive at the event. The dinner is being held in long straight corridor in which people sit in a way such that they won't leave any empty space in between two consecutive persons at any given time.
When a person number i arrives at the corridor, he must go and stand to the immediate right of the person numbered A[i] (if A[i] = 0, then this person just stands at the leftmost end of the line).
But there is a problem, as there is no space between two consecutive persons at any given time, so for this person to sit, space must be created by moving either all the persons to left of the place to the left one step each, or all the persons to right of the place to the right one step each.
Now, Sereja is wondering about what could be the minimum number of steps people will take so as to sit in the dinner party. Please find it fast, so that Sereja can peacefully entertain his guests.
-----Input-----
First line of input contain an integer T — the number of test cases. T tests follow.
First line of each test case contain the integer N, and the next line contains N integers — A[1], A[2], ... , A[N].
-----Output-----
For each test case, output a single line with the answer — the minimal number of steps required.
-----Constraints-----
- 1 ≤ T ≤ 100
- 1 ≤ N ≤ 100
- 0 ≤ A[i] < i
-----Example-----
Input:
3
1
0
3
0 0 0
5
0 1 2 1 4
Output:
0
0
3
-----Explanation-----
Example case 3.
- First three persons don't need any steps to sit. The line after the arrangement of these persons will look like [1, 2, 3].
- When person #4 comes in, he wants to sit to the right of person 1, so we need to either move the first person to the left, or the second and third persons to the right. The first case is clearly better. Now the line will look like [1, 4, 2, 3].
- When person #5 arrives, he will need to move 2 persons in either case. The final arrangement will be [1, 4, 5, 2, 3].
So total number of steps people moved during the entire process is 1 + 2 = 3. So the answer is 3.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
a=eval(input())
while(a):
x=eval(input())
b=list(map(int,input().split()))
z=[0]*100
k=1
j=0
c=0
for i in b:
if i==0:
z.insert(i,k)
else:
if z[z.index(i)+1]==0:
z.insert(j,k)
else:
m=z.index(i)
n=m+1
p=(len(z)-z.count(0))-n
c=c+min(n,p)
z.insert(m+1,k)
k+=1
j+=1
m=0
n=0
p=0
print(c)
a-=1
``` | {
"language": "python",
"test_cases": [
{
"input": "3\n1\n0\n3\n0 0 0\n5\n0 1 2 1 4\n",
"output": "0\n0\n3\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/COOK64/problems/SEALINE"
} | vfc_3394 | false | false | false | false | false |
apps | verifiable_code | 1139 | Solve the following coding problem using the programming language python:
The chef is very expert in coding, so to keep his password safe from the hackers. He always enters a decoded code of his password. You are a hacker and your work is to find the maximum number of possible ways to unlock his password in encoded form.
The encoded message containing only letters from A-Z is being encoded with numbers using the following mapping:
'A' -> 1
'B' -> 2 ...
'Z' -> 26
You have given a non-empty string containing only digits, determine the total number of ways to encode it.
If the total number of ways are even then you are able to unlock the password.
Input:
The first line has a single integer T, denoting the number of test cases. The first line of each test case contains string “S” decoded number.
Output:
For each test case, in a new line, print 'YES' if number of maximum ways are even, otherwise
'NO'. (without quotes)
Constraints:
1 ≤ T ≤ 50
1 ≤ S ≤ 30
Sample Input:
2
12
223
Sample Output:
YES
NO
Explanation:
For first test case, It could be encoded as "AB" (1 2) or "L" (12), hence the number of
maximum possible ways are 2 so output is “YES”.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
t = int(input())
while t>0:
s = input().strip()
if not s:
print('NO')
dp = [0 for x in range(len(s) + 1)]
dp[0] = 1
dp[1] = 1 if 0 < int(s[0]) <= 9 else 0
for i in range(2, len(s) + 1):
if 0 < int(s[i-1:i]) <= 9:
dp[i] += dp[i - 1]
if s[i-2:i][0] != '0' and int(s[i-2:i]) <= 26:
dp[i] += dp[i - 2]
if dp[len(s)]%2 == 0:
print('YES')
else:
print('NO')
t -= 1
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n12\n223\n",
"output": "YES\nNO\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/CY302020/problems/CODEY302"
} | vfc_3398 | false | false | false | false | false |
apps | verifiable_code | 1140 | Solve the following coding problem using the programming language python:
Consider the following algorithm
order(arr, i) {
if length(arr) <= 1 {
return arr
}
l = []
r = []
n = length(arr) - 1
for j in 0, 1, ..., n {
if ( (arr[j] modulo power(2,i+1)) < power(2,i) ) {
append arr[j] to l
}else{
append arr[j] to r
}
}
l = order(l, i + 1)
r = order(r, i + 1)
c = concatenate(l, r)
return c
}
Note that $concatenate(l, r)$ returns an array which is the array $l$, followed by the array $r$. Similarly $power(x,y)$ returns $x^y$.
Let $a$ be the array $a_0,a_1,a_2,a_3, \ldots,a_n$ where $a_j = j$ for each index $j$ and the last index $n = (2^p-1)$ for a fixed integer parameter $p$. Given an integer $p$ and an index $idx$, your task is calculate the element at index $idx$ in the array returned by executing $order(a, 0)$.
For example, suppose $ p = 3$ and $idx = 3$.
- The initial array is $a = [0, 1, 2, 3, 4, 5, 6, 7]$.
- Executing $order(a, 0)$ first creates two new arrays $l == [0, 2, 4, 6]$ and $r == [1, 3, 5, 7]$.
- Next, $order(l, 1)$ and $order(r, 1)$ are executed.
- $order(l, 1)$, in turn, executes $order([0, 4], 2)$ and $order([2, 6], 2)$ which return $[0, 4]$ and $[2, 6]$, respectively. These are then concatenated, so $order(l, 1)$ returns $[0, 4, 2, 6]$.
- Similarly, $order(r, 1)$ returns $[1, 5, 3, 7]$.
- These two are concatenated as the final result, so the array returned by $order(a, 0)$ is $[0, 4, 2, 6, 1, 5, 3, 7]$.
So, if the input is $p = 3$, and $idx = 3$, the answer is $6$. If $p = 3$ and $idx = 7$, the answer should be $7$.
-----Input Format:-----
- The first line contains a single integer, $T$, which is the number of testcases. The description of each testcase follows.
- Each testcase is described by a single line with two integers: $p$ and $idx$, where $p$ is the parameter that determines the length of the array $a$ and $idx$ is the index at which you have to report the value in the output of $order(a, 0)$.
-----Output Format:-----
- You should print the answer in a new line for each testcase, which should be a single integer, the element at index $idx$ after executing $order(a, 0)$ for the array $a$ defined by the parameter $p$.
-----Constraints:-----
- $1 \leq T \leq 10$
- $1 \leq p \leq 50$
- $0 \leq idx \leq 2^p-1$
-----SUBTASKS:-----
- Subtask 1: 20% points : $1 \leq p \leq 20$
- Subtask 2: 80% points: Original constraints
-----Sample Input:-----
2
3 3
3 7
-----Sample Output:-----
6
7
-----Explanation:-----
Both the testcases have been explained in the problem statement.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
for _ in range(int(input())):
p, idx = map(int, input().split())
b = bin(idx)[2:]
b = ('0' * (p - len(b)) + b)[::-1]
print(int(b, 2))
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n3 3\n3 7\n",
"output": "6\n7\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/ZCOPRAC/problems/ZCO20001"
} | vfc_3402 | false | false | false | false | false |
apps | verifiable_code | 1141 | Solve the following coding problem using the programming language python:
A tourist is visiting Byteland. The tourist knows English very well. The language of Byteland is rather different from English. To be exact it differs in following points:
- Bytelandian alphabet has the same letters as English one, but possibly different in meaning. Like 'A' in Bytelandian may be 'M' in English. However this does not mean that 'M' in Bytelandian must be 'A' in English. More formally, Bytelindian alphabet is a permutation of English alphabet. It will be given to you and could be any possible permutation. Don't assume any other condition.
- People of Byteland don't like to use invisible character for separating words. Hence instead of space (' ') they use underscore ('_'). Other punctuation symbols, like '?', '!' remain the same as in English.
The tourist is carrying "The dummies guide to Bytelandian", for translation. The book is serving his purpose nicely. But he is addicted to sharing on BaceFook, and shares his numerous conversations in Byteland on it. The conversations are rather long, and it is quite tedious to translate for his English friends, so he asks you to help him by writing a program to do the same.
-----Input-----
The first line of the input contains an integer T, denoting the length of the conversation, and the string M, denoting the English translation of Bytelandian string "abcdefghijklmnopqrstuvwxyz". T and M are separated by exactly one space. Then T lines follow, each containing a Bytelandian sentence S which you should translate into English. See constraints for details.
-----Output-----
For each of the sentence in the input, output its English translation on a separate line. Replace each underscores ('_') with a space (' ') in the output. Each punctuation symbol (see below) should remain the same. Note that the uppercase letters in Bytelandian remain uppercase in English, and lowercase letters remain lowercase. See the example and its explanation for clarity.
-----Constraints-----
- 1 ≤ T ≤ 100
- M is a permutation of "abcdefghijklmnopqrstuvwxyz"
- Each sentence is non-empty and contains at most 100 characters
- Each sentence may contain only lowercase letters ('a'-'z'), uppercase letters ('A'-'Z'), underscores ('_') and punctuation symbols: dot ('.'), comma (','), exclamation ('!'), question-mark('?')
-----Example-----
Input:
5 qwertyuiopasdfghjklzxcvbnm
Ph
Pcssi
Bpke_kdc_epclc_jcijsc_mihyo?
Epcf_kdc_liswhyo_EIED_hy_Vimcvpcn_Zkdvp_siyo_viyecle.
Ipp!
Output:
Hi
Hello
What are these people doing?
They are solving TOTR in Codechef March long contest.
Ohh!
-----Explanation-----
The string "qwertyuiopasdfghjklzxcvbnm" means that 'a' in Bytelandian is 'q' in English, 'b' in Bytelandian is 'w' in English, 'c' in Bytelandian is 'e' in English and so on.
Thus to translate "Ph" (first sentence in example) to English:
1) We find that 'p' in Bytelandian means 'h' in English. So we replace 'P' with 'H'.
2) Then we see that 'h' in Bytelandian means 'i' in English. So we replace 'h' with 'i'.
3) Therefore, the translation is "Hi".
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
try:
t,m=input().split()
t=int(t)
m=list(m)
letters=list("abcdefghijklmnopqrstuvwxyz")
trans={}
for i in range(len(letters)):
trans[letters[i]]=m[i]
for i in range(t):
x=list(input())
y=""
for j in x:
if(j.isalpha()==True):
if(j.isupper()==True):
y+=trans[j.lower()].upper()
else:
y+=trans[j]
else:
if(j=='_'):
y+=" "
else:
y+=j
print(y)
except:pass
``` | {
"language": "python",
"test_cases": [
{
"input": "and its\n",
"output": "",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/TOTR"
} | vfc_3406 | false | false | false | false | false |
apps | verifiable_code | 1142 | Solve the following coding problem using the programming language python:
This is one more story about our old friend, the Despotic King. Once every year, it was customary for the king to give audience to the rich merchants of his country in a large hall. On that day, the merchants were ushered in to meet the king one by one and after paying their respects to the king they were seated in the auditorium.
It was the job of the minister to introduce each merchant, as he arrived, to the others in the hall. He would announce his name and his wealth. However, our quirky king demanded that in addition, he should also announce the rank of the merchant among all those in the hall (at the time of his arrival) in terms of his wealth.
For example, let us suppose that the wealth of the 6 merchants who met the king (in the order in which they arrived) is given by the sequence
78246840398978246840398978 \quad 24 \quad 68 \quad 40 \quad 39 \quad 89
Then, clearly the first merchant is the richest in the hall when he enters it (since there are no others in the hall) and so his rank is $1$. Since $24 < 78$ the rank of the second merchant when he enters the hall is $2$. The rank of the third merchant is also $2$ since $24 < 68 < 78$. The rank of the fourth merchant is $3$ since $24 < 40 < 68 < 78$, the rank of the fifth merchant is $4$ since $24 < 39 < 40 < 68 < 78$ and finally the rank of the sixth merchant is $1$ since $24 < 39 < 40 < 68 < 78 < 89$. The sequence of ranks announced by the minister would thus be:
1223411223411 \quad 2 \quad 2 \quad 3 \quad 4 \quad 1
Your task is to write a program that takes as input a sequence of distinct positive integers indicating the wealth of the merchants in the order in which they visit the king and outputs the sequence of ranks announced by the minister.
-----Input:-----
The first line contains a single integer $N$ indicating the number of merchants. The next $N$ lines (line $2,...,N+1$) describe the wealth of these $N$ merchants. Line $i+1$ contains a single positive integer indicating the wealth of the $i^{th}$ merchant to enter the hall.
-----Output:-----
Your output should consist of $N$ lines. Line $i$ should be the rank announced when the $i^{th}$ minister enters the hall.
-----Constraints:-----
- $1 \leq N \leq 45000$.
- No two merchants have the same wealth.
- You may also assume that in $30 \%$ of of the inputs $1 \leq N \leq 8000$.
-----Sample Input-----
6
78
24
68
40
39
89
-----Sample Output-----
1
2
2
3
4
1
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
arr=[]
n=int(input())
for i in range(n):
a=int(input())
arr.append(a)
arr.sort()
p=arr.index(a)
print((i-p)+1)
``` | {
"language": "python",
"test_cases": [
{
"input": "6\n78\n24\n68\n40\n39\n89\n",
"output": "1\n2\n2\n3\n4\n1\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/IARCSJUD/problems/IARANK"
} | vfc_3410 | false | false | false | false | false |
apps | verifiable_code | 1143 | Solve the following coding problem using the programming language python:
Yash likes playing with numbers. He has a challenge for you. Yash gives
you a number that he made by multiplying two numbers. He claims that the
possible sum of the two numbers he multiplied is as minimum as possible. He
challenges you to find that minimum sum.
Formally, for a given value of N, you are required to find the minimum sum of two distinct numbers x and y such that x, y > 0 and xy = N.
-----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.
Each testcase contains single integer N.
-----Output:-----
For each testcase, output minimum x + y such that x*y = N and x,y >0.
-----Constraints :-----
$1 \leq T \leq 100$
$1 < N \leq 10^{12}$
-----Sample Input:-----
1
852140
-----Sample Output:-----
1929
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 isPrime(n) :
# Corner cases
if (n <= 1) :
return False
if (n <= 3) :
return True
# This is checked so that we can skip
# middle five numbers in below loop
if (n % 2 == 0 or n % 3 == 0) :
return False
i = 5
while(i * i <= n) :
if (n % i == 0 or n % (i + 2) == 0) :
return False
i = i + 6
return True
t=int(input())
for i in range(0,t):
n=int(input())
if n==1:
print("2")
continue
if isPrime(n):
print(n+1)
continue
if n%2==0:
k=n//2
min=2+k
else:
min=n+1
for j in range(2,(n//2)+1):
if n%j==0:
k=n//j
if k!=j:
l=j+k
if l<min:
min=l
print(min)
``` | {
"language": "python",
"test_cases": [
{
"input": "1\n852140\n",
"output": "1929\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/CHLG2020/problems/MINI2"
} | vfc_3414 | false | false | false | false | false |
apps | verifiable_code | 1144 | Solve the following coding problem using the programming language python:
Devu loves to play with binary strings a lot. One day he borrowed a binary string s of size n from his friend Churu. Before starting to play with it, he wants to make sure that string does not contain more than k consecutive equal characters. For achieving that, only kind of operation he is allowed to perform is to flip any ith character of the string.
As Devu is always in hurry to meet his girlfriend, he wants you to help him in finding out the minimum number of operations he will need. Also he wants you to print one of the possible modified string too.
-----Input-----
- First line of input contains an integer T denoting the number of test cases.
- For each test case, there are two lines.
- First line contains two space separated integers n, k as defined in the problem.
- Next line contains string s of size n.
-----Output-----
- For each test case, print two lines.
- First line should contain an integer corresponding to minimum number of operations Devu needs.
- In second line, print one of the possible modified strings.
-----Constraints-----
Subtask #1: 20 points
- 1 ≤ T ≤ 100, 1 ≤ n ≤ 20, 1 ≤ k ≤ n
Subtask #2: 35 points
- 1 ≤ T ≤ 102, 1 ≤ n ≤ 103, 1 ≤ k ≤ n
Subtask #3: 45 points
- 1 ≤ T ≤ 105, 1 ≤ n ≤ 105, 1 ≤ k ≤ n
- Sum of n over all the test cases is ≤ 106
-----Example-----
Input:
3
2 1
11
2 2
11
4 1
1001
Output:
1
10
0
11
2
1010
-----Explanation-----
Example case 1: As 1 is occurring twice consecutively, we can convert 11 to 10 in a single operation.
Example case 2: You don't need to modify the string as it does not have more than 2 equal consecutive character.
Example case 3: As 0 is occurring twice consecutively, we can convert 1001 to 1010 in a two operations (Flip third and fourth character).
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
T= int(input());
for i in range(T):
n,k = list(map(int,input().split()));
s=list(map(int,input()));
if k==1:
s_0 ={};
s_1={};
c0=0;
c1=0;
for j in range(n):
if(j%2==0):
s_1[j]=1;
s_0[j]=0;
else:
s_1[j]=0;
s_0[j]=1;
for j in range(n):
if(s_0[j]-s[j]!=0):
c0+=1;
if(s_1[j]-s[j]!=0):
c1+=1;
if c0<c1:
print(c0);
p_s="";
for j in range(n):
p_s+=str(s_0[j]);
print(p_s);
else:
print(c1);
p_s="";
for j in range(n):
p_s+=str(s_1[j]);
print(p_s);
else:
count=1;
c=s[0];
flips=0
for j in range(1,n):
if(s[j]==c):
count+=1;
#print count;
if count > k:
if(j+1<n and s[j]==s[j+1]):
if(s[j]==1):
s[j]=0;
else:
s[j]=1;
else:
if(s[j-1]==1):
s[j-1]=0;
else:
s[j-1]=1;
flips+=1;
count=1;
elif(s[j]!=c):
count=1;
c=s[j];
print(flips);
p_s="";
for j in range(n):
p_s+=str(s[j]);
print(p_s);
``` | {
"language": "python",
"test_cases": [
{
"input": "3\n2 1\n11\n2 2\n11\n4 1\n1001\n",
"output": "1\n10\n0\n11\n2\n1010\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/DEVSTR"
} | vfc_3418 | false | false | false | false | false |
apps | verifiable_code | 1145 | Solve the following coding problem using the programming language python:
In a bizarre game of chess ,knight was so drunk, that instead of his usual move he started walking straight. In every move Knight jumps on 2n steps forward (n is number of block that he had travelled so far from starting) but after that he has to take either 1 step forward or backward.
Now the Knight needs to get to position X so King (i.e. You) needs to decide the order of his backward or forward step in such a way that he can reach its destination in minimum number of steps. Remember he always travels in a straight line and the length of the board is infinite.
-----Input-----
The first line of the input contains an integer T denoting the number of test cases, for each test case enter value X ( i.e. destination)
Note : initially knight is at n = 1.
-----Output-----
For each test case the output should be string of numbers 1 & 2 where 1 denotes backward step and 2 denote the forward step
Note : for no solution print 0.
-----Constraints-----
- 1 ≤ T ≤ 100
- 1 ≤ X ≤ 10^10
-----Example-----
Input:
2
17
10
Output:
2111
0
-----Explanation-----
Case 1 : starting from n = 1 , knight moves to n = 3 ('2') , 5 ('1') , 9 ('1') , 17 ('1') i.e. string printed is 2 1 1 1
Case 2 : no solution is possible
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 log,pow
n=int(input())
a=[]
for i in range(n):
no=int(input())
if(no%2==0):
a.append("0")
elif(no==1):
a.append("1")
elif(no==3):
a.append("3")
else:
s="2"
lv=int(log(no,2))
clv=1
cno=3
while(cno!=no):
if(no<cno*pow(2,lv-clv)):
s=s+"1"
clv=clv+1
cno=(2*cno)-1
else:
s=s+"2"
clv=clv+1
cno=(2*cno)+1
a.append(s)
for i in a:
print(i)
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n17\n10\n",
"output": "2111\n0\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/ALGT2013/problems/TNMALG07"
} | vfc_3422 | false | false | false | false | false |
apps | verifiable_code | 1146 | Solve the following coding problem using the programming language python:
[Chopsticks (singular: chopstick) are short, frequently tapered sticks used in pairs of equal length, which are used as the traditional eating utensils of China, Japan, Korea and Vietnam. Originated in ancient China, they can also be found in some areas of Tibet and Nepal that are close to Han Chinese populations, as well as areas of Thailand, Laos and Burma which have significant Chinese populations. Chopsticks are most commonly made of wood, bamboo or plastic, but in China, most are made out of bamboo. Chopsticks are held in the dominant hand, between the thumb and fingers, and used to pick up pieces of food.]
Retrieved from wikipedia
Actually, the two sticks in a pair of chopsticks need not be of the same length. A pair of sticks can be used to eat as long as the difference in their length is at most D. The Chef has N sticks in which the ith stick is L[i] units long. A stick can't be part of more than one pair of chopsticks. Help the Chef in pairing up the sticks to form the maximum number of usable pairs of chopsticks.
-----Input-----
The first line contains two space-separated integers N and D. The next N lines contain one integer each, the ith line giving the value of L[i].
-----Output-----
Output a single line containing the maximum number of pairs of chopsticks the Chef can form.
-----Constraints-----
- 1 ≤ N ≤ 100,000 (10 5 )
- 0 ≤ D ≤ 1,000,000,000 (10 9 )
- 1 ≤ L[i] ≤ 1,000,000,000 (10 9 ) for all integers i from 1 to N
-----Example-----
Input:
5 2
1
3
3
9
4
Output:
2
-----Explanation-----
The 5 sticks have lengths 1, 3, 3, 9 and 4 respectively. The maximum allowed difference in the lengths of two sticks forming a pair is at most 2.
It is clear that the 4th stick (length 9) cannot be used with any other stick.
The remaining 4 sticks can can be paired as (1st and 3rd) and (2nd and 5th) to form 2 pairs of usable chopsticks.
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
a,b=list(map(int,input().split()))
ls=[]
for i in range(a):
ls.append(int(input()))
ls.sort()
c=0;i=0
while i<(a-1):
if ls[i+1]-ls[i]<=b:
c=c+1
i=i+1
i=i+1
print(c)
``` | {
"language": "python",
"test_cases": [
{
"input": "5 2\n1\n3\n3\n9\n4\n",
"output": "2\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/TACHSTCK"
} | vfc_3426 | false | false | false | false | false |
apps | verifiable_code | 1147 | Solve the following coding problem using the programming language python:
You are given a string S containing only lowercase characters.
You can rearrange the string and you have to print minimum number of characters needed(can be 0) to make it palindrome.
-----Input:-----
- First line contain an interger T denoting number of testcases.
- First line of each testcase contains integer N, size of string.
- Second line of each testcase contains string S.
-----Output:-----
For each test case, print a single line containing one integer ― the minimum number of characters needed(can be 0) to make it palindrome.
-----Constraints-----
- $1 \leq T \leq 1000$
- $1 \leq N \leq 10^5$
-----Sample Input:-----
3
1
a
9
abbbcbddd
6
abcdef
-----Sample Output:-----
0
2
5
-----EXPLANATION:-----
- Example case 1: a is already a palindrome.
- Example case 2: abbddcddbba is palindrome by adding 2 more characters.
- Example case 3: abdefcfedba is palindrome by adding 5 more characters.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
# cooking dish here
from sys import stdin
from collections import Counter
read = stdin.readline
for testcase in range(int(read())):
length = int(read())
string = read().strip()
counts = Counter(string)
odd_counts = 0
for count in list(counts.values()):
# print(count, counts)
odd_counts += count%2
print(max(odd_counts-1, 0))
``` | {
"language": "python",
"test_cases": [
{
"input": "3\n1\na\n9\nabbbcbddd\n6\nabcdef\n",
"output": "0\n2\n5\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/CDGO2021/problems/PALINDRO"
} | vfc_3430 | false | false | false | false | false |
apps | verifiable_code | 1148 | Solve the following coding problem using the programming language python:
In ACM-ICPC contests, there are usually three people in a team. For each person in the team, you know their scores in three skills - hard work, intelligence and persistence.
You want to check whether it is possible to order these people (assign them numbers from 1 to 3) in such a way that for each 1 ≤ i ≤ 2, i+1-th person is stricly better than the i-th person.
A person x is said to be better than another person y if x doesn't score less than y in any of the skills and scores more than y in at least one skill.
Determine whether such an ordering exists.
-----Input-----
The first line fo the input contains an integer T denoting the number of test cases.
Each test consists of three lines. Each of these lines contains three space separated integers s1, s2 and s3 denoting the scores of one member of the team in each of the three skills, in the given order.
-----Output-----
For each test case, output a single line containing "yes" if such an ordering exists or "no" if doesn't exist (without quotes).
-----Constraints-----
- 1 ≤ T ≤ 1000
- 1 ≤ s1, s2, s3 ≤ 100
-----Example-----
Input
3
1 2 3
2 3 4
2 3 5
1 2 3
2 3 4
2 3 4
5 6 5
1 2 3
2 3 4
Output
yes
no
yes
-----Explanation-----
Test Case 1: We can order them as (3, 2, 1). Person 3 is better than Person 2 because his scores in the first two skills are not lesser than Person 2's. And in skill 3, Person 3 scores higher. Similarly, Person 2 is better than Person 1. He scores more than Person 1 in every skill, in fact.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
def g(x,y):
d = x[0]>=y[0] and x[1]>=y[1] and x[2]>=y[2]
e= x[0]>y[0] or x[1]>y[1] or x[2]>y[2]
return d and e
t=int(input())
for _ in range(t):
a=list(map(int,input().split()))
b=list(map(int,input().split()))
c=list(map(int,input().split()))
if g(a,b) and g(b,c):
print('yes')
elif g(a,c) and g(c,b):
print('yes')
elif g(b,a) and g(a,c):
print('yes')
elif g(b,c) and g(c,a):
print('yes')
elif g(c,a) and g(a,b):
print('yes')
elif g(c,b) and g(b,a):
print('yes')
else:
print('no')
``` | {
"language": "python",
"test_cases": [
{
"input": "3\n1 2 3\n2 3 4\n2 3 5\n1 2 3\n2 3 4\n2 3 4\n5 6 5\n1 2 3\n2 3 4\n",
"output": "yes\nno\nyes\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/ORDTEAMS"
} | vfc_3434 | false | false | false | false | false |
apps | verifiable_code | 1149 | Solve the following coding problem using the programming language python:
Chef had an interesting dream last night. He dreamed of a new revolutionary chicken recipe. When he woke up today he tried very hard to reconstruct the ingredient list. But, he could only remember certain ingredients. To simplify the problem, the ingredient list can be represented by a string of lowercase characters 'a' - 'z'.
Chef can recall some characters of the ingredient list, all the others, he has forgotten. However, he is quite sure that the ingredient list was a palindrome.
You are given the ingredient list Chef dreamed last night. The forgotten characters are represented by a question mark ('?'). Count the number of ways Chef can replace the forgotten characters with characters 'a' - 'z' in such a way that resulting ingredient list is a palindrome.
-----Input-----
The first line of input contains a single integer T, the number of test cases. T lines follow, each containing a single non-empty string - the ingredient list as recalled by Chef. Whatever letters he couldn't recall are represented by a '?'.
-----Output-----
For each test case, output a single line containing the number of valid ways the ingredient list could be completed. Since the answers can be very large, output each answer modulo 10,000,009.
-----Example-----
Input:
5
?
??
ab?
a?c
aba
Output:
26
26
1
0
1
-----Constraints-----
1 ≤ T ≤ 20
1 ≤ sum of length of all input strings ≤ 1,000,000
Each input string contains only lowercase roman letters ('a' - 'z') or question marks.
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):
l = input()
n= len(l)
prod = 1
for k in range(n//2):
i = l[k]
j = l[n-k-1]
if ((i!=j) and (i!='?' and j!="?") ):
prod=0
break
elif ((i==j) and (i=='?')):
prod*=26
prod = prod%10000009
if n%2!=0:
if l[n//2]=="?":
prod*=26
print(prod)
``` | {
"language": "python",
"test_cases": [
{
"input": "5\n?\n??\nab?\na?c\naba\n",
"output": "26\n26\n1\n0\n1\nConstraints\n1 ≤ T ≤ 20\n1 ≤ sum of length of all input strings ≤ 1,000,000\nEach input string contains only lowercase roman letters ('a' - 'z') or question marks.\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/RRECIPE"
} | vfc_3438 | false | false | false | false | false |
apps | verifiable_code | 1150 | Solve the following coding problem using the programming language python:
In the 2-D world of Flatland, the Circles were having their sports day and wanted to end it with a nice formation. So, they called upon Mr. Sphere from Spaceland for help. Mr Sphere decides to arrange the Circles in square formations. He starts with $N$ Circles and forms the largest possible square using these Circles. He then takes the remaining Circles and repeats the procedure. A square of side $S$ requires $S^2$ Circles to create.
Find the number of squares he will be able to form at the end of the process.
-----Input:-----
- First line will contain $T$, number of testcases. Then the testcases follow.
- Each testcase contains of a single integer $N$.
-----Output:-----
For each testcase, output a single integer denoting the number of squares.
-----Constraints-----
- $1 \leq T \leq 1000$
- $1 \leq N \leq 1000$
-----Sample Input:-----
2
85
114
-----Sample Output:-----
2
4
-----EXPLANATION:-----
Test case 1 : Mr Sphere forms a square of side 9 using 81 Circles and then forms a square of side 2 using the remaining 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
import math
for _ in range(int(input())):
n=int(input())
c=0
while(n>0):
i=int(math.sqrt(n))
c+=1
n=n-i**2
print(c)
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n85\n114\n",
"output": "2\n4\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/ICL1902"
} | vfc_3442 | false | false | false | false | false |
apps | verifiable_code | 1151 | Solve the following coding problem using the programming language python:
There is a city with $N$ numbered $0 - N-1$ shops. A market is a place where we can reach from one shop to another using some road. There are $M$ roads in this city connecting each connecting any two shops.
Find the number of markets in the city.
NOTE: A market having only one shop is also a valid market.
-----Input:-----
- First line will contain $T$, number of testcases. Then the testcases follow.
- First line of Each Test Case is $N, M$, denoting the number of shops and the number of roads respectively.
- Next M lines consist of two integers $A$ and $B$ denoting that there exists a road between Shop A and Shop B
-----Output:-----
For each testcase, output the number of markets.
-----Constraints-----
- $1 \leq T \leq 100$
- $1 \leq N,M \leq 10^3$
- $0 \leq A,B < N$
-----Sample Input:-----
1
5 3
0 1
2 3
3 4
-----Sample Output:-----
2
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
from sys import stdin
from math import ceil, gcd
# Input data
#stdin = open("input", "r")
def dfs(src, visit):
visit[src] = 1
for nbr in d[src]:
if visit[nbr] == 0:
dfs(nbr, visit)
for _ in range(int(stdin.readline())):
n, m = list(map(int, stdin.readline().split()))
d = {}
for i in range(m):
u, v = list(map(int, stdin.readline().split()))
if u in d:
d[u].append(v)
else:
d[u] = [v]
if v in d:
d[v].append(u)
else:
d[v] = [u]
visited = {}
for i in range(n):
visited[i] = 0
ans = 0
for i in range(n):
if visited[i] == 0:
ans += 1
if i in d:
dfs(i, visited)
print(ans)
``` | {
"language": "python",
"test_cases": [
{
"input": "1\n5 3\n0 1\n2 3\n3 4\n",
"output": "2\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/ENAU2020/problems/ECAUG206"
} | vfc_3446 | false | false | false | false | false |
apps | verifiable_code | 1152 | Solve the following coding problem using the programming language python:
Chef Jessie has a lot of recipes with her (N). She often remembered the starting few characters of the recipe and forgot the rest. As all the great chefs do, Jessie also numbered the recipes depending on the priority. So, given the list of recipes along with their priorities answer Jessie’s queries.
Jessie’s queries are as follows:
She gives you the first few characters of a recipe; you have to print the complete recipe with the highest priority.
Note:
Every recipe has a unique priority
-----Input-----
First line contains an integer N - the number of recipes.
Followed by N strings Si along with an integer each Vi.
Si stands for the recipe and Vi for the priority.
It is followed by an integer Q - the number of queries.
Followed by Q strings Qi.
Each string Si, Qi contain only lowercase Latin alphabets ('a' - 'z') and '-'.
-----Output-----
Q – lines, each contain the answer for each of the query.
If for a query no recipe matches print "NO". (Without quotes)
Constraints:
0 <= N <= 1000
0 <= Q <= 1000
-10^9 <= Vi <= 10^9
1 <= |Si| <= 1000 (length of Si)
1 <= |Qi| <= 1000 (length of Qi)
-----Example-----
Input:
4
flour-with-eggs 100
chicken-ham -10
flour-without-eggs 200
fish-with-pepper 1100
6
f
flour-with
flour-with-
c
fl
chik
Output:
fish-with-pepper
flour-without-eggs
flour-with-eggs
chicken-ham
flour-without-eggs
NO
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
nr=int(input())
d={}
for r in range(nr):
s,v=list(map(str,input().split()))
d[int(v)]=s
q=int(input())
lis=[]
for i in range(q):
lis.append(input())
l=list(d.keys())
l.sort(reverse=True)
ans='NO'
for j in lis:
ans='NO'
for k in l:
if len(j)<=len(d[k]):
a=d[k]
if j==a[0:len(j)]:
ans=a
break
print(ans)
``` | {
"language": "python",
"test_cases": [
{
"input": "4\nflour-with-eggs 100\nchicken-ham -10\nflour-without-eggs 200\nfish-with-pepper 1100\n6\nf\nflour-with\nflour-with-\nc\nfl\nchik\n",
"output": "fish-with-pepper\nflour-without-eggs\nflour-with-eggs\nchicken-ham\nflour-without-eggs\nNO\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/TWSTR"
} | vfc_3450 | false | false | false | false | false |
apps | verifiable_code | 1153 | Solve the following coding problem using the programming language python:
-----Problem Statement-----
Sereja has a sequence of n integers a[1], a[2], ..., a[n]. Sereja can do following transformation of the array:
- create a new sequence of n integers b[1], b[2], ..., b[n]in this way: (1 ≤ i ≤ n)
- Replace the sequence a by b, i.e., a[i] = b[i] for all i in [1, n]
Sereja decided to use his transformation k times. Then he computed the value of , where r — the sequence obtained after k transformations of sequence a, as described above.
Sereja lost sequence a, but he was left with the numbers q(r) and k. Now Sereja is interested in the question : what is the number of the sequences of the integers с[1], с[2], ..., с[n], such that 1 ≤ c[i] ≤ m and q(d) = q(r), where d — the sequence obtained after k transformations of sequence c, as described above.
-----Input-----
The first lines contains a single integer T, denoting the number of test cases. Each test case consist of four integers : n, m, q(r), k.
-----Output-----
In a single line print the remainder of division the answer of the problem on number 10^9 + 7.
-----Constraints-----
- 1 ≤ T ≤ 10000
- 1 ≤ n, m, q(r), k ≤ 10^9
-----Example-----
Input:
3
1 1 1 1
2 2 1 1
2 3 1 1
Output:
0
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 mod(a,b,c):
x = 1
y = a
while(b>0):
if(b%2==1):
x = (x*y)%c
y = (y*y)%c
b /=2
return x%c
t = int(input())
num = 10**9+7
for i in range(t):
n,m,q,k = list(map(int,input().split()))
if m<=q:
print(0)
else:
a1 = m-q
a2 = mod(q+1,n,num)
a3 = mod(q-1,n,num)
a4 = mod(q,n,num)
a5 = a2-2*a4+a3
ans = a1*a5
print(ans%num)
``` | {
"language": "python",
"test_cases": [
{
"input": "3\n1 1 1 1\n2 2 1 1\n2 3 1 1\n",
"output": "0\n2\n4\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/SEATRSF"
} | vfc_3454 | false | false | false | false | true |
apps | verifiable_code | 1154 | Solve the following coding problem using the programming language python:
Chef and his friends are playing the game AMONG US. They all have chosen their names as numbers. There are N people in Chef’s group including him, and each swears that he is not the imposter. However, it turns out there were N+1 people in the game. Now all that Chef needs to know is the name of the imposter, which is a number. Also remember that numbers can be duplicate. Can you help out Chef in finding the imposter?
Input :
First line contains the value of N. Second line contains the N numbers that Chef’s friends used as their names. Third line contains the N+1 numbers that people in the game have used as their names.
Output :
Print the extra number in new line.
Constraints :
1 ≤ Numbers used as names ≤ 1,000
1 ≤ N ≤ 1,000,000
Sample Input :
3
4 2 5
4 2 3 5
Sample Output :
3
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
try:
n=int(input())
x=[*list(map(int, input().split()))]
y=[*list(map(int, input().split()))]
for i in y:
d=x.count(i)-y.count(i)
if d!=0:
print(i)
break
except: pass
``` | {
"language": "python",
"test_cases": [
{
"input": "3\n4 2 5\n4 2 3 5\n",
"output": "3\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/CSTR2020/problems/AMONGUS"
} | vfc_3458 | false | false | false | false | false |
apps | verifiable_code | 1155 | Solve the following coding problem using the programming language python:
Autobots are instructed by Optimus Prime to mobilize in the form of a rectangular shape with each Autobot on each vertex of the rectangle region on a -”deployment area” (which may consist of one or more regions). This is done so as to take care of the inner rectangular area called “region”. However the rule states-“no two regions may overlap”. You have been asked to remove some regions from the “deployment area” so the remaining regions do not obscure each other. To keep the disturbance to the minimum level, you should remove the minimum number of regions to achieve this goal. You may not remove a region and place it in another position; all regions you leave in “deployment area” must be in their original position.
When you examined the “deployment area”, you noticed something very nice. Every region was placed on the deployment area by placing each autobot in the four corners. This was done in a very courteous manner since each autobot is guarding only the region it is holding.
The reason Optimus Prime wants your help because you are good at taking down a single region without disturbing the rest, even if that region is obscured by many others.
-----Input-----
The first line consists of a single integer T indicating the number of test cases (about 25).
Each test case consists begins with a single integer n indicating the number of regions. The next n lines consist of 4 integers x0, x1, y0, and y1 satisfying x0 < x1 and y0 < y1. This means the region covers all points (x,y) satisfying x0 <= x <= x1 and y0 <= y <= y1.
As stated before hand, no corner of any region will intersect any other region anywhere. That is, if (x,y) is a corner point of one region and another region is described by x0, x1, y0, and y1, then we do not have x0 <= x <= x1 and y0 <= y <= y1.
Bounds: 1 <= n <= 100 and each integer in a region description fits in a signed 32 bit integer.
-----Output-----
The output for each test case is a single line containing a single integer that is the maximum number of regions that can be left on the wall such that no two regions share a common point in the deployment area.
-----Example-----
Input:
1
4
0 4 0 4
1 3 1 2
2 3 1 3
3 4 1 3
Output:
2
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
print
``` | {
"language": "python",
"test_cases": [
{
"input": "1\n4\n0 4 0 4\n1 3 1 2\n2 3 1 3\n3 4 1 3\n",
"output": "2\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/TCTR2012/problems/NOPC2"
} | vfc_3462 | false | false | false | false | false |
apps | verifiable_code | 1156 | Solve the following coding problem using the programming language python:
Write a program, which takes an integer N and if the number is less than 10 then display "Thanks for helping Chef!" otherwise print "-1".
-----Input-----
The first line contains an integer T, total number of testcases. Then follow T lines, each line contains an integer N.
-----Output-----
For each test case, output the given string or -1 depending on conditions, in a new line.
-----Constraints-----
- 1 ≤ T ≤ 1000
- -20 ≤ N ≤ 20
-----Example-----
Input
3
1
12
-5
Output
Thanks for helping Chef!
-1
Thanks for helping 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 i in range(int(input())):
x=int(input())
if x<10:
print("Thanks for helping Chef!")
else:
print("-1")
``` | {
"language": "python",
"test_cases": [
{
"input": "3\n1\n12\n-5\n",
"output": "Thanks for helping Chef!\n-1\nThanks for helping Chef!\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/FLOW008"
} | vfc_3466 | false | false | false | false | false |
apps | verifiable_code | 1157 | Solve the following coding problem using the programming language python:
Today is the planned day tor Thik and Ayvak's wedding. Kark is infatuated with Ayvak. He offers to play a game with Thik. Whosoever wins, will get to marry Ayvak. Ayvak, who values games of chance over all the other things in life, agrees to this.
Kark sets up an N by M grid (N rows, M columns), labelled from left to right and top to bottom consecutively with numbers from 1 to M*N, with 1 at the top left corner and M*N at the bottom right corner. For example, a labelled 3 by 6 grid looks as follows:
Kark has already painted K unit squares of the grid with a heart each. Next, Thik randomly picks a rectangle with sides on the grid lines, and having a positive area, with each valid rectangle having an equal probability of being chosen. Three distinct possibilities for Thik's rectangle in the 3 by 6 grid are shown below:
The nine different rectangles in a 2 by 2 grid are shown below:
If Thik's rectangle contains at least half of the hearts, Thik gets to marry Ayvak. Otherwise, Kark will marry Ayvak. Kark wants to know whether or not he has an advantage here, so he wants to know the expected value of the number of hearts a randomly chosen rectangle will cover. I'm sure that you have a good heart, so please, cover this job for him.
-----Input-----
The first line of input contains one integer T, the number of test cases.
For each test case, the first line contains 3 space-separated integers N, M, K, as described in the problem statement. The next line contains K space-separated integers, each a single number from 1 to M*N, representing a square that is painted with a heart. It is guaranteed that all K integers are distinct.
-----Output-----
Output T lines, each containing a single real number, containing the expected number of hearts that a randomly chosen rectangle will contain. The answer will be considered correct if its relative or absolute error does not exceed 10-6.
-----Constraints-----
- 1 ≤ T ≤ 5
- 1 ≤ N, M ≤ 107
- 1 ≤ K ≤ 105
- Each of the K integers representing a heart are between 1 and N*M, inclusive. All K integers are distinct.
-----Subtasks-----Subtask 1 (15 points) :
- 1 ≤ N, M ≤ 10
- 1 ≤ K ≤ N * M
Subtask 2 (85 points) : no additional constraints
-----Example-----
Input:
1
2 2 2
1 2
Output:
0.8888888888888888
-----Explanation-----
There are a total of 9 possible rectangles Thik could draw, shown in the figure above, and grid squares 1 and 2 are painted with a heart. The top row of possible selections (shown in the figure) contain 1, 0, 1, 2, and 2 hearts (from left to right), and the bottom row of possible selections (in the figure) contain 1, 0, 1, and 0 hearts. Therefore, 3/9 of the time 0 hearts are contained in the rectangle, 4/9 of the times 1 heart is contained in the rectangle, and 2/9 of the time 2 hearts are contained in the rectangle. The expected value is then 0 * 3/9 + 1 * 4/9 + 2 * 2/9 = 8/9.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
# cook your dish here
# cook your dish here
for i in range(int(input())):
n,m,k=map(int,input().split())
l,ans = list(map(int,input().split())),0
for i in l:
r=i//m + 1;c=i%m
if(c==0):c=m;r-=1
ans+=r*(n+1-r)*c*(m+1-c)
ans/=((n+1)*(m+1)*n*m)//4
print(ans)
``` | {
"language": "python",
"test_cases": [
{
"input": "1\n2 2 2\n1 2\n\n\n",
"output": "0.8888888888888888\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/RECTLOVE"
} | vfc_3470 | false | false | false | false | false |
apps | verifiable_code | 1158 | Solve the following coding problem using the programming language python:
Recently, chef Ciel often hears about lucky numbers.
Everybody knows that lucky numbers are positive integers
whose decimal representation contains only the lucky digits 4 and 7.
For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
Ciel decides to make Ciel numbers.
As you know, Ciel likes the digit 8 very much.
And then, Ciel likes the digits 5 and 3.
So Ciel defines Ciel numbers as the positive integers k such that d(k, 8) ≥ d(k, 5) ≥ d(k, 3) and d(k, i) = 0 for all i = 0, 1, 2, 4, 6, 7, 9,
where d(k, i) denotes the number of the digit i in the decimal representation of the integer k.
For example, the first few Ciel numbers are 8, 58, 85, 88, 358, 385, 538, 583, 588, 835, 853, 858, 885, 888, ....
Ciel's restaurant has N menus.
And Ciel want to know how many menus have Ciel numbers as their price.
Your task is to find it.
-----Input-----
The first line contains an integer N.
Then N lines follow.
Each line has the name Si of the menu and its price Pi separated by a single space.
-----Output-----
Print the number of menus whose prices are one of Ciel numbers.
-----Constraints-----
1 ≤ N ≤ 1000
1 ≤ |Si| ≤ 100, where |Si| denotes the length of Si
Each letter of Si is either an alphabetical letter or a digit or a single quotation mark or a space.
1 ≤ Pi < 1000000 (106)
Pi contains no leading zeros.
-----Sample Input-----
6
milk 58
Ciel's Drink 80
The curry 2nd edition 888888
rice omelet 85855
unagi 1
The first and last letters can be a space 358
-----Sample Output-----
3
-----Output details-----
58 and 888888 and 358 are Ciel numbers.
80 and 85855 and 1 are not Ciel numbers.
-----Notes-----
Different operating systems have different ways of representing a newline; do not assume one particular way will be used.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
#!/usr/bin/env python
def main():
N = int(input())
C = 0
for n in range(N):
S = input().strip()
Pi = S.split()[-1]
L = [Pi.count(k) for k in map(str, list(range(10)))]
if L[8] >= L[5] and L[5] >= L[3] and \
L[0] == 0 and L[1] == 0 and \
L[2] == 0 and L[4] == 0 and \
L[6] == 0 and L[7] == 0 and \
L[9] == 0: C += 1
print(C)
main()
``` | {
"language": "python",
"test_cases": [
{
"input": "6\nmilk 58\nCiel's Drink 80\nThe curry 2nd edition 888888\nrice omelet 85855\nunagi 1\nThe first and last letters can be a space 358\n",
"output": "3\nOutput details\n58 and 888888 and 358 are Ciel numbers.\n80 and 85855 and 1 are not Ciel numbers.\nNotes\nDifferent operating systems have different ways of representing a newline; do not assume one particular way will be used.\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/COOK20/problems/CIELNUM2"
} | vfc_3474 | false | false | false | false | false |
apps | verifiable_code | 1159 | Solve the following coding problem using the programming language python:
Abhi and his friends (Shanky,Anku and Pandey) love to play with strings. Abhi invented a simple game. He will give a string S to his friends. Shanky and Anku will play the game while Pandey is just a spectator. Shanky will traverse the string from beginning (left to right) while Anku will traverse from last (right to left). Both have to find the first character they encounter during their traversal,that appears only once in the entire string. Winner will be one whose character is alphabetically more superior(has higher ASCII value). When it is not possible to decide the winner by comparing their characters, Pandey will be the winner.
-----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 contains a string S having only lowercase alphabets ( a..z ).
-----Output-----
For each test case, output a single line containing "SHANKY" if Shanky is the winner or "ANKU" if Anku is the winner or "PANDEY" if the winner is Pandey. Output your answer without quotes.
-----Constraints-----
- 1 ≤ T ≤ 100
- 1 < |S| ≤ 10^5
-----Example-----
Input:
3
google
breakraekb
aman
Output:
SHANKY
PANDEY
ANKU
-----Explanation-----
Example case 2. Both Shanky and Anku can not find any such character. Hence it is not possible to decide the winner between these two. So Pandey is the winner.
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 e in range(t):
str = input()
dict = {}
for x in range(len(str)):
if str[x] in dict:
dict[str[x]] = -1
else:
dict[str[x]] = x
shankyIndex = len(str)
ankuIndex = -1
for x in dict:
if dict[x] != -1:
if dict[x] < shankyIndex:
shankyIndex = dict[x]
if dict[x] > ankuIndex:
ankuIndex = dict[x]
ankuLetter = 0
shankyLetter = 0
if ankuIndex != -1:
ankuLetter = str[ankuIndex]
else:
print('PANDEY')
continue
if shankyIndex != len(str):
shankyLetter = str[shankyIndex]
else:
print('PANDEY')
continue
if shankyLetter > ankuLetter:
print('SHANKY')
elif ankuLetter > shankyLetter:
print('ANKU')
else:
print('PANDEY')
``` | {
"language": "python",
"test_cases": [
{
"input": "3\ngoogle\nbreakraekb\naman\n",
"output": "SHANKY\nPANDEY\nANKU\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/RECJ1601/problems/ABHSTR"
} | vfc_3478 | false | false | false | false | false |
apps | verifiable_code | 1160 | Solve the following coding problem using the programming language python:
Chef is an advocate for Go Green Initiative. Today he had n trees planted in a row outside his his restaurant. Today, the height of i-th tree is hi feet. The trees grow at a rate of mi feet per day.
Chef knows that trees will look beautiful if they form a zig-zag sequence. The trees will be said to be in Zig-zag sequence if the heights of tree first increases or decreases, then alternates between decreasing/increasing respectively. Formally, the trees will be said to in Zig-zag sequence if one of the following two conditions holds.
- h1 < h2 > h3 < h4 and so on..
- h1 > h2 < h3 > h4 and so on..
Chef wants to know intervals of time when the heights of the trees will form a zig-zag sequence.
-----Input-----
The first line of the input contains an integer T denoting the number of test cases. The description of T test cases follows.
The first line of each test case contains a single integer n, denoting the number of trees.
The ith of following N lines contains two space separated integers hi and mi, denoting the initial height and the growth speed for ith tree.
-----Output-----
For each test case, output an integer Q - the amount of the periods of consecutive moments of time, when the trees for a zig-zag sequence.
On the following Q lines, output the intervals of time when the trees' heights form a zig-zag sequence. For each intervals, output its' smallest and the largest instants of time. If the range is infinite, output Inf as the right bound.
The test cases are designed in such a way that the total output won't exceed 2 MB.
-----Constraints-----
- 1 ≤ T ≤ 105
- 1 ≤ n ≤ 10
- Subtask 1 (23 points): 0 ≤ hi, mi ≤ 10
- Subtask 2 (77 points): 0 ≤ hi, mi ≤ 109
- 1 ≤ sum of n over a test cases in a single test file ≤ 5 × 105
-----Example-----
Input:3
3
0 1
2 2
0 3
2
2 1
1 2
3
1 1
2 2
3 3
Output:1
0 1
2
0 0
2 Inf
0
-----Explanation-----
Example case 1. In the first case 0 2 0 is already a zig-zag sequence, but on the 2nd second it will become 2 6 6 and will never turn back into zig-zag
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
def get(l,n):
l1,l2 = [],[]
i = 1
h1,m1 = l[0]
while (i < len(l)):
h2,m2 = l[i]
if (h1>h2):
if (m1 >= m2):
l1 += [(0,10**20)]
l2 += [(-1,-1)]
else:
d = (h1-h2)//(m2-m1)
if (((h1-h2)%(m2-m1)) == 0):
l1 += [(0,d-1)]
l2 += [(d+1,10**20)]
else:
l1 += [(0,d)]
l2 += [(d+1,10**20)]
elif(h1==h2):
if (m1 > m2):
l1 += [(1,10**20)]
l2 += [(-1,-1)]
elif(m1==m2):
l1 += [(-1,-1)]
l2 += [(-1,-1)]
else:
l2 += [(1,10**20)]
l1 += [(-1,-1)]
else:
if (m1 <= m2):
l2 += [(0,10**20)]
l1 += [(-1,-1)]
else:
d = (h2-h1)//(m1-m2)
if ((h2-h1)%(m1-m2) == 0):
l2 += [(0,d-1)]
l1 += [(d+1,10**20)]
else:
l2 += [(0,d)]
l1 += [(d+1,10**20)]
i += 1
h1,m1 = h2,m2
return l1,l2
def intersect(k1,k2):
k1,k2 = min(k1,k2),max(k1,k2)
c1,c2 = k1
c3,c4 = k2
l = [c1,c2,c3,c4]
l.sort()
if (l[2]==c2):
return (c3,min(c2,c4))
elif (l[3]==c2):
return k2
else:
return (-1,-1)
def union(k1,k2):
k1,k2 = min(k1,k2),max(k1,k2)
c1,c2 = k1
c3,c4 = k2
l = [c1,c2,c3,c4]
l.sort()
if (c2==l[3]):
return ([c1,c2])
elif(c2==l[2] or ((c3-c2) == 1)):
return([c1,c4])
else:
return([c1,c2,c3,c4])
def aa(l1,l2,n):
c1,c2 = 0,10**20
i = 0
n -= 1
while (i < n):
if (i%2 == 0):
k1,k2 = l1[i]
else:
k1,k2 = l2[i]
i += 1
if ((k1,k2) == (-1,-1)):
return (-1,-1)
c1,c2 = intersect((c1,c2),(k1,k2))
if ((c1,c2) == (-1,-1)):
return (c1,c2)
return (c1,c2)
test = int(input())
while (test != 0):
test -= 1
n = int(input())
l = []
i = 0
while (i < n):
c1,c2 = list(map(int,input().split()))
l += [(c1,c2)]
i += 1
if (n == 1):
print(1)
print("0 Inf")
else:
l1,l2 = (get(l,n))
k1,k2 = aa(l1,l2,n)
if ((k1,k2) == (-1,-1)):
k1,k2 = aa(l2,l1,n)
if ((k1,k2) == (-1,-1)):
print(0)
else:
print(1)
if (k2 == 10**20):
k2 = "Inf"
print(str(k1) + " " +str(k2))
else:
k3,k4 = aa(l2,l1,n)
if ((k3,k4) == (-1,-1)):
print(1)
if (k2 == 10**20):
k2 = "Inf"
print(str(k1) + " " +str(k2))
else:
p = union((k1,k2),(k3,k4))
if (len(p)==2):
c1,c2 = p
if (c2==10**20):
c2 = "Inf"
print(1)
print(str(c1) + " " +str(c2))
else:
c1,c2,c3,c4 = p
if (c4 == 10**20):
c4 = "Inf"
print(2)
print(str(c1) + " " +str(c2))
print(str(c3) + " " +str(c4))
``` | {
"language": "python",
"test_cases": [
{
"input": "3\n3\n0 1\n2 2\n0 3\n2\n2 1\n1 2\n3\n1 1\n2 2\n3 3\n",
"output": "1\n0 1\n2\n0 0\n2 Inf\n0\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/AUG16/problems/CHAHG"
} | vfc_3482 | false | false | false | false | false |
apps | verifiable_code | 1161 | Solve the following coding problem using the programming language python:
In Snakeland, there are some snakes and mongooses. They are lined up in a row. The information about how exactly they are lined up it is provided to you by a string of length n. If the i-th character of this string is 's', then it means that there is a snake at the i-th position, whereas the character 'm' denotes a mongoose.
You might have heard about the age-old rivalry between hares and tortoises, but in Snakeland, the rivalry between snakes and mongooses is much more famous. The snakes and the mongooses want to hold a final poll in which the ultimate winner of this age-old battle will be decided. If the snakes get more votes than the mongooses, they will be the ultimate winners. Similarly, if the mongooses get more votes than snakes, they will be the ultimate winners. Obviously, each animal is loyal to their species, i.e. each snake will vote for the snakes to be the ultimate champions and each mongoose for the mongooses.
Tomorrow's the election day. Before the elections, the mongooses decided to cheat. They planned that each mongoose will eat at most one of its neighbor snakes. Two animals are said to be neighbors of each other if they are consecutive to each other in the row. After this, the elections will be held. The mongooses planned in such a way that the number of snakes eaten is maximized. Can you find out who will win the final poll? Output "snakes", "mongooses" or "tie" correspondingly.
-----Input-----
First line of the input contains an integer T denoting the number of test cases. The description of T test cases follow.
The only line of each test case contains a string consisting of characters 's' and 'm'.
-----Output-----
For each test case output a single line containing "snakes", "mongooses" or "tie" correspondingly (without quotes).
-----Constraints-----
- 1 ≤ T ≤ 100
- 1 ≤ |s| ≤ 100
-----Example-----
Input
4
sm
ssm
sms
ssmmmssss
Output
mongooses
tie
tie
snakes
-----Explanation-----
Example 1. The mongoose will eat the snake. Only the mongoose will be left. So, on the election day, there is one mongoose and zero snakes. So mongooses will win.
Example 2. The mongoose will eat the snake at position 2 (1-based indexing). One mongoose and one snake will be left. Hence, there will be a tie.
Example 3. The mongoose can eat either the snake to its left or to the right. But, it can eat only one of them. Afterwards, there will be a single snake and mongoose. So, it will result in a tie.
Example 4. The mongooses can eat at max two snakes. For example, s*mmm*sss, where * denotes the snakes that were eaten by mongooses. After this, we have four snakes and three mongooses. So, the snakes win.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
for i in range(int(input())):
a=input()
c=a.count('m')
d=a.count('s')
t=0
while t<len(a)-1:
if (a[t]=='m' and a[t+1]=='s') or (a[t]=='s' and a[t+1]=='m'):
d=d-1
t=t+2
else:
t=t+1
if c>d:
print('mongooses')
elif d>c:
print('snakes')
else:
print('tie')
``` | {
"language": "python",
"test_cases": [
{
"input": "4\nsm\nssm\nsms\nssmmmssss\n",
"output": "mongooses\ntie\ntie\nsnakes\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/SNELECT"
} | vfc_3486 | false | false | false | false | false |
apps | verifiable_code | 1162 | Solve the following coding problem using the programming language python:
Every great chef knows that lucky numbers are positive integers whose decimal representations contain only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
Our chef has recently returned from the Lucky country. He observed that every restaurant in the Lucky country had a lucky number as its name.
He believes that having a lucky number as a restaurant name can indeed turn out to be very lucky.
Our chef believes that it is possible to make a lucky number having N digits even luckier. Any number following the rules below is called Lucky lucky number -
1. The number contains only digits 4 and 7.
2. Count of digit 4 in the number should be divisible by 7.
3. Count of digit 7 in the number should be divisible by 4.
Help our chef to compute the count of digit 4 in the smallest Lucky lucky number having N digits.
-----Input-----
First line contains T, number of test cases. Each of the next T lines contains a number N, the number of digits in the Lucky lucky number to be formed.
1<=T<=1000
1<=N<=1000000000 (10^9)
-----Output-----
If it is not possible to form a Lucky lucky number having N digits, output -1.
Otherwise, output the count of digit 4 in the smallest Lucky lucky number having N digits.
-----Example-----
Input:
5
7
4
11
1
15
Output:
7
0
7
-1
7
Explanation
For the last test case, N = 15, the smallest lucky lucky number is
444444477777777. The count of digit 4 is 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
import os
def __starting_point():
start = 0
for line in sys.stdin:
if start == 0:
start = 1
continue
else:
try:
n = int(line.strip())
# print n
q = n/7
rem = n%7
if rem==0:
res = n
elif rem==1:
res = (q-1)*7
elif rem==2:
res = (q-2)*7
elif rem==3:
res = (q-3)*7
elif rem==4:
res = q*7
elif rem==5:
res = (q-1)*7
elif rem==6:
res = (q-2)*7
if res < 0:
print(-1)
else:
print(res)
except:
break
__starting_point()
``` | {
"language": "python",
"test_cases": [
{
"input": "5\n7\n4\n11\n1\n15\n\n\n",
"output": "7\n0\n7\n-1\n7\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/MAY12/problems/CHEFLUCK"
} | vfc_3490 | false | false | false | false | false |
apps | verifiable_code | 1163 | Solve the following coding problem using the programming language python:
Who's interested in football?
Rayne Wooney has been one of the top players for his football club for the last few years. But unfortunately, he got injured during a game a few months back and has been out of play ever since.
He's got proper treatment and is eager to go out and play for his team again. Before doing that, he has to prove to his fitness to the coach and manager of the team. Rayne has been playing practice matches for the past few days. He's played N practice matches in all.
He wants to convince the coach and the manager that he's improved over time and that his injury no longer affects his game. To increase his chances of getting back into the team, he's decided to show them stats of any 2 of his practice games. The coach and manager will look into the goals scored in both the games and see how much he's improved. If the number of goals scored in the 2nd game(the game which took place later) is greater than that in 1st, then he has a chance of getting in. Tell Rayne what is the maximum improvement in terms of goal difference that he can show to maximize his chances of getting into the team. If he hasn't improved over time, he's not fit to play. Scoring equal number of goals in 2 matches will not be considered an improvement. Also, he will be declared unfit if he doesn't have enough matches to show an improvement.
-----Input:-----
The first line of the input contains a single integer T, the number of test cases.
Each test case begins with a single integer N, the number of practice matches Rayne has played.
The next line contains N integers. The ith integer, gi, on this line represents the number of goals Rayne scored in his ith practice match. The matches are given in chronological order i.e. j > i means match number j took place after match number i.
-----Output:-----
For each test case output a single line containing the maximum goal difference that Rayne can show to his coach and manager. If he's not fit yet, print "UNFIT".
-----Constraints:-----
1<=T<=10
1<=N<=100000
0<=gi<=1000000 (Well, Rayne's a legend! You can expect him to score so many goals!)
-----Example:-----Input:
3
6
3 7 1 4 2 4
5
5 4 3 2 1
5
4 3 2 2 3
Output:
4
UNFIT
1
Explanation:
In the first test case, Rayne can choose the first and second game. Thus he gets a difference of 7-3=4 goals. Any other pair would give him a lower improvement.
In the second test case, Rayne has not been improving in any match. Thus he's declared UNFIT.
Note: Large input data. Use faster I/O methods. Prefer scanf,printf over cin/cout.
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 j in range(0,T):
line1, line2 = input(), input()
seq = line2.split()
current_min = 1000001
current_max = 0
max_spread = 0
for i in range(0,len(seq)):
current_value = int(seq[i])
if current_min > current_value:
current_min = current_value
current_max = current_value
elif current_max < current_value:
current_max = current_value
if max_spread < (current_max - current_min):
max_spread = current_max - current_min
if max_spread > 0:
print(max_spread)
else:
print("UNFIT")
``` | {
"language": "python",
"test_cases": [
{
"input": "3\n6\n3 7 1 4 2 4\n5\n5 4 3 2 1\n5\n4 3 2 2 3\n",
"output": "4\nUNFIT\n1\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/APRIL12/problems/PLAYFIT"
} | vfc_3494 | false | false | false | false | false |
apps | verifiable_code | 1164 | Solve the following coding problem using the programming language python:
Mandarin chinese
, Russian and Vietnamese as well.
Chef is organising a contest with $P$ problems (numbered $1$ through $P$). Each problem has $S$ subtasks (numbered $1$ through $S$).
The difficulty of a problem can be calculated as follows:
- Let's denote the score of the $k$-th subtask of this problem by $SC_k$ and the number of contestants who solved it by $NS_k$.
- Consider the subtasks sorted in the order of increasing score.
- Calculate the number $n$ of valid indices $k$ such that $NS_k > NS_{k + 1}$.
- For problem $i$, the difficulty is a pair of integers $(n, i)$.
You should sort the problems in the increasing order of difficulty levels. Since difficulty level is a pair, problem $a$ is more difficult than problem $b$ if the number $n$ is greater for problem $a$ than for problem $b$, or if $a > b$ and $n$ is the same for problems $a$ and $b$.
-----Input-----
- The first line of the input contains two space-separated integers $P$ and $S$ denoting the number of problems and the number of subtasks in each problem.
- $2P$ lines follow. For each valid $i$, the $2i-1$-th of these lines contains $S$ space-separated integers $SC_1, SC_2, \dots, SC_S$ denoting the scores of the $i$-th problem's subtasks, and the $2i$-th of these lines contains $S$ space-separated integers $NS_1, NS_2, \dots, NS_S$ denoting the number of contestants who solved the $i$-th problem's subtasks.
-----Output-----
Print $P$ lines containing one integer each — the indices of the problems in the increasing order of difficulty.
-----Constraints-----
- $1 \le P \le 100,000$
- $2 \le S \le 30$
- $1 \le SC_i \le 100$ for each valid $i$
- $1 \le NS_i \le 1,000$ for each valid $i$
- in each problem, the scores of all subtasks are unique
-----Subtasks-----
Subtask #1 (25 points): $S = 2$
Subtask #2 (75 points): original constraints
-----Example Input-----
3 3
16 24 60
498 861 589
14 24 62
72 557 819
16 15 69
435 779 232
-----Example Output-----
2
1
3
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
p,s = [int(i) for i in input().split()]
scores = {}
for j in range(1, p + 1):
sc = [int(i) for i in input().split()]
ns = [int(i) for i in input().split()]
nsc = dict(list(zip(sc,ns)))
ssc = sorted(sc)
score = 0
for a,b in zip(ssc[:-1], ssc[1:]):
if nsc[a] > nsc[b]:
score += 1
if score in list(scores.keys()) :
scores[score].append(j)
else :
scores[score] = [j]
total_scores = sorted(list(scores.keys()))
final_list = []
for val in total_scores :
final_list += sorted(scores[val])
for val in final_list :
print(val)
``` | {
"language": "python",
"test_cases": [
{
"input": "3 3\n16 24 60\n498 861 589\n14 24 62\n72 557 819\n16 15 69\n435 779 232\n",
"output": "2\n1\n3\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/PROBLEMS"
} | vfc_3498 | false | false | false | false | false |
apps | verifiable_code | 1165 | Solve the following coding problem using the programming language python:
Chef will not be able to attend the birthday of his best friend Rock. He promised Rock that this will not be the case on his half birthday. To keep his promise Chef must know Rock’s next half birthday accurately. Being busy, he is assigning this work to you.
Half birthday is the day that occurs exactly between two subsequent birthdays.
You will be provided with Rock’s birthdate and birth month, you will have to figure out his half birthday.
$Note$: Consider every year to be a leap year and all months are displayed in lowercase English characters.
-----Input:-----
- The first line of the input contains a single integer $T$ denoting the number of test cases.
- The description of each of the $T$ test cases contains an integer $d$ followed by a string, denoting month $m$.
- Here $d$ denotes day of a month and $m$ denotes the month of a year respectively.
-----Output:-----
For each test case print an integer $d1$ followed by a string, denoting month $m1$, which overall denotes date and month of Rock’s half birthday.
-----Constraints:-----
- $1 \leq T \leq 10^5$
- $1 \leq d , d1 \leq 31$
- $january \leq m , m1 \leq december$
-----Sample Input:-----
3
15 january
31 august
10 october
-----Sample Output:-----
16 july
1 march
10 april
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
d = {'january':31,'february':29,'march':31,
'april':30,'may':31,'june':30,'july':31,
'august':31,'september':30,'october':31,
'november':30,'december':31}
#l=[[15,'january'],[31,'august'],[10,'october']]
l2 = list(d.keys())
for _ in range(int(input())):
l=input().split()
l[0]=int(l[0])
a = l[1]
ind = l2.index(a)
b = 183 - (d[l[1]] - l[0])
while b!=0:
if ind!=11:
ind+=1
else:
ind = 0
if b<=d[l2[ind]]:
print(b,l2[ind])
break
b-=d[l2[ind]]
``` | {
"language": "python",
"test_cases": [
{
"input": "3\n15 january\n31 august\n10 october\n",
"output": "16 july\n1 march\n10 april\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/PAHC2020/problems/HALFBDAY"
} | vfc_3502 | false | false | false | false | false |
apps | verifiable_code | 1166 | Solve the following coding problem using the programming language python:
Little Elephant is playing a game with arrays. He is given an array A0, A1, ..., AN−1 of N integers. And then Q queries are given, each containing an integer K. He has to tell how many subarrays satisfy the condition: the function foo returns K when it is applied to the subarray.
In this problem, a subarray is defined as a sequence of continuous elements Ai, Ai+1, ..., Aj where 0 ≤ i ≤ j ≤ N−1. The function foo, when applied to an array, returns the minimum of all the elements in the array.
For example, foo returns 5 when it is applied to the array [7, 5, 10, 7, 5, 8]. Please note that the subarrays Ai, Ai+1, ..., Aj and Ak, Ak+1, ..., Al are different if and only if i ≠ k or j ≠ l in this problem.
-----Input-----
The first line of input contains N, denoting the size of the array. The next line contains N space separated integers A0, A1, ..., AN−1, denoting the array. Then the next line contains Q, denoting the number of queries. Each query consists of one integer per line, denoting K.
-----Output-----
For each query, print the required number of subarrays.
-----Constraints-----
- 1 ≤ N ≤ 50
- 1 ≤ Ai ≤ 1000000 (106)
- 1 ≤ Q ≤ 10
- 1 ≤ K ≤ 1000000 (106)
-----Example-----
Input:
5
4 1 2 3 4
4
3
4
6
1
Output:
2
2
0
8
-----Explanation-----
Query 1. Only the two subarrays [3, 4] and [3] satisfy.
Query 2. Again only the two subarrays [4] and [4] satisfy. Please note that these subarrays (A0 and A4) are considered different.
Query 3. No subarray satisfies.
Query 4. The eight subarrays [4, 1], [4, 1, 2], [4, 1, 2, 3], [4, 1, 2, 3, 4], [1], [1, 2], [1, 2, 3] and [1, 2, 3, 4] satisfy.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
import sys
import math
def main(arr,k):
ans=0
for i in range(len(arr)):
curr_min=float('inf')
for j in range(i,len(arr)):
curr_min=min(curr_min,arr[j])
if curr_min==k:
ans+=1
return ans
n=int(input())
arr=list(map(int,input().split()))
for i in range(int(input())):
print(main(arr,int(input())))
``` | {
"language": "python",
"test_cases": [
{
"input": "5\n4 1 2 3 4\n4\n3\n4\n6\n1\n\n\n",
"output": "2\n2\n0\n8\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/SUBMIN"
} | vfc_3506 | false | false | false | false | false |
apps | verifiable_code | 1167 | Solve the following coding problem using the programming language python:
Tom has finally taken over the business empire and now looking for
a new Name of the business to make a new start.
Joe (Tom's dear friend) suggested a string $S$ consisting of
Uppercase and lowercase letters
Tom wants to make some changes as per the following criteria:
1) String should $not$ have any vowels .
2) Every other uppercase consonant(other characters except vowels) should
be in lowercase
For ex:
If the consonant character is Z then it should be z
3) There should be a character "." before each consonant.
Help Tom to make the required Changes.
-----Input:-----
- First line will contain string $S$,This string only consists of uppercase and lowercase letters.
-----Output:-----
Print the resulting string. It is guaranteed that this string is not empty.
-----Constraints-----
- Length of string is in [1 .. 100]
-----Sample Input:-----
$CodeSprInT$
-----Sample Output:-----
.c.d.s.p.r.n.t
-----EXPLANATION:-----
C is a consonant and it is in uppercase so turn it in lower case and add a “.” before it
o is a vowel so it is deleted
d is a consonant and in lowercase so just add a “.” before it
e is a vowel so it is deleted
S is a consonant and it is in uppercase so turn it in lower case and add a “.” before it
p is a consonant and in lowercase so just add a “.” before it
r is a consonant and in lowercase so just add a “.” before it
I is a vowel so it is deleted
n is a consonant and in lowercase so just add a “.” before it
T is a consonant and it is in uppercase so turn it in lower case and add a “.” before it
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
s = input().lower()
vow = ["a", "e", "i", "o", "u", "y"]
ans = ""
for ch in s:
if ch in vow:
continue
if ch.isalpha():
ans += "." + ch
print(ans)
``` | {
"language": "python",
"test_cases": [
{
"input": "CodeSprInT\n",
"output": ".c.d.s.p.r.n.t\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/SPRT2020/problems/EMPRNM"
} | vfc_3510 | false | false | false | false | true |
apps | verifiable_code | 1168 | Solve the following coding problem using the programming language python:
Abhishek is fond of playing cricket very much. One morning, he is playing cricket with his friends. Abhishek is a right-hand batsman
.He has to face all types of balls either good or bad. There are total 26 balls in the game and each ball is represented
by one of the following two ways:-
1. "g" denotes a good ball.
2. "b" denotes a bad ball.
All 26 balls are represented by lower case letters (a,b,.....z).
Balls faced by Abhishek are represented as a string s, all the characters of which are lower case i.e, within 26 above mentioned balls.
A substring s[l...r] (1≤l≤r≤|s|) of string s=s1s2...s|s| (where |s| is the length of string s) is string slsl+1...sr.
The substring s[l...r] is good, if among the letters slsl+1...sr, there are at most k bad ones (refer sample explanation ).
Your task is to find out the number of distinct good substrings for the given string s. Two substrings s[x...y] and s[p...q] are considered distinct if their contents are different, i.e. s[x...y]≠s[p...q].
-----Input Format-----
First Line contains an integer T, number of test cases. For each test case, first line contains a string - a sequence of balls faced by Abhishek.
And, next line contains a string of characters "g" and "b" of length 26 characters. If the ith character of this string equals "1", then the i-th English letter is good, otherwise it's bad. That is, the first character of this string corresponds to letter "a", the second one corresponds to letter "b" and so on.
And, the third line of the test case consists of a single integer k (0≤k≤|s|) — the maximum acceptable number of bad characters in a good substring.
-----Output Format -----
For each test case, print a single integer — the number of distinct good substrings of string s.
-----Constraints-----
- 1<=T<=1000
- 1<=|s|<=2000
- 0<=k<=|s|
-----Subtasks-----
Subtask 1 : 20 Points
- 1<=T<=10
- 1<=|s|<=20
- 0<=k<=|s|
Subtask 2 : 80 Points
Original Constraints
Sample Input
2
ababab
bgbbbbbbbbbbbbbbbbbbbbbbbb
1
acbacbacaa
bbbbbbbbbbbbbbbbbbbbbbbbbb
2
Sample Output
5
8
Explanation
In the first test case there are following good substrings: "a", "ab", "b", "ba", "bab".
In the second test case there are following good substrings: "a", "aa", "ac", "b", "ba", "c", "ca", "cb".
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
import sys
for _ in range(0,eval(input())):
d,inp,mp,n,q=set(),list(map(ord,list(sys.stdin.readline().strip()))),[x=='b' for x in list(sys.stdin.readline().strip())],eval(input()),ord('a')
inps = [inp[i:] for i in range(len(inp))]
inps.sort()
op,prev= 0,''
for ip in inps:
i,ct=0,0
while i < min(len(ip),len(prev)):
if prev[i] != ip[i]:
break
if mp[ip[i]-q]:
ct = ct+ 1
i = i+1
while i < len(ip):
if mp[ip[i]-q]:
ct = ct + 1
if ct > n:
break
op,i= op+1,i+1
prev = ip
print(op)
``` | {
"language": "python",
"test_cases": [
{
"input": "2\nababab\nbgbbbbbbbbbbbbbbbbbbbbbbbb\n1\nacbacbacaa\nbbbbbbbbbbbbbbbbbbbbbbbbbb\n2\n",
"output": "5\n8\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/ICOD2016/problems/ICODE16G"
} | vfc_3514 | false | false | false | false | false |
apps | verifiable_code | 1169 | Solve the following coding problem using the programming language python:
This is a simple game you must have played around with during your school days, calculating FLAMES of you and your crush! Given the names of two people, cancel out the common letters (repeated occurrence of a letter is treated separately, so 2A's in one name and one A in the other would cancel one A in each name), count the total number of remaining letters (n) and repeatedly cut the letter in the word FLAMES which hits at the nth number when we count from F in cyclic manner.
For example:
NAME 1: SHILPA
NAME 2: AAMIR
After cutting the common letters:
NAME 1: SHILPA
NAME 2: AAMIR
Total number of letters left=7
FLAMES, start counting from F : 1=F, 2=L, 3=A, 4=M, 5=E, 6=S,7=F...So cut F
FLAMES: repeat this process with remaining letters of FLAMES for number 7 (start count from the letter after
the last letter cut) . In the end, one letter remains. Print the result corresponding to the last letter:
F=FRIENDS
L=LOVE
A=ADORE
M=MARRIAGE
E=ENEMIES
S=SISTER
-----Input-----
The no. of test cases (<100)
two names (may include spaces) for each test case.
-----Output-----
FLAMES result (Friends/Love/...etc) for each test case
-----Example-----
Input:
2
SHILPA
AAMIR
MATT
DENISE
Output:
ENEMIES
LOVE
By:
Chintan, Asad, Ashayam, Akanksha
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 joseph(k, n=6):
if k==0:
k = 1
x = 0
for i in range(2,n+1):
x = (x+k)%i
return x
FLAMES = ['FRIENDS', 'LOVE', 'ADORE', 'MARRIAGE', 'ENEMIES', 'SISTER']
nCase = int(sys.stdin.readline())
for _ in range(nCase):
a = ''.join(sys.stdin.readline().split())
b = ''.join(sys.stdin.readline().split())
n = 0
for ch in set(a+b):
n += abs(a.count(ch)-b.count(ch))
print(FLAMES[joseph(n)])
``` | {
"language": "python",
"test_cases": [
{
"input": "2\nSHILPA\nAAMIR\nMATT\nDENISE\n\n\n\n",
"output": "ENEMIES\nLOVE\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/IGNS2012/problems/IG01"
} | vfc_3518 | false | false | false | false | false |
apps | verifiable_code | 1170 | Solve the following coding problem using the programming language python:
In order to establish dominance amongst his friends, Chef has decided that he will only walk in large steps of length exactly $K$ feet. However, this has presented many problems in Chef’s life because there are certain distances that he cannot traverse. Eg. If his step length is $5$ feet, he cannot travel a distance of $12$ feet. Chef has a strict travel plan that he follows on most days, but now he is worried that some of those distances may become impossible to travel. Given $N$ distances, tell Chef which ones he cannot travel.
-----Input:-----
- The first line will contain a single integer $T$, the number of test cases.
- The first line of each test case will contain two space separated integers - $N$, the number of distances, and $K$, Chef’s step length.
- The second line of each test case will contain $N$ space separated integers, the $i^{th}$ of which represents $D_i$, the distance of the $i^{th}$ path.
-----Output:-----
For each testcase, output a string consisting of $N$ characters. The $i^{th}$ character should be $1$ if the distance is traversable, and $0$ if not.
-----Constraints-----
- $1 \leq T \leq 1000$
- $1 \leq N \leq 1000$
- $1 \leq K \leq 10^9$
- $1 \leq D_i \leq 10^9$
-----Subtasks-----
- 100 points : No additional constraints.
-----Sample Input:-----
1
5 3
12 13 18 20 27216
-----Sample Output:-----
10101
-----Explanation:-----
The first distance can be traversed in $4$ steps.
The second distance cannot be traversed.
The third distance can be traversed in $6$ steps.
The fourth distance cannot be traversed.
The fifth distance can be traversed in $9072$ steps.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
t=int(input())
for i in range(0,t):
n,k=map(int,input().split())
a1,*a=map(int,input().split())
a.insert(0,a1)
j=0
while j<n:
if a[j]%k==0:
print(1,end="")
else:
print(0,end="")
j+=1
print("")
``` | {
"language": "python",
"test_cases": [
{
"input": "1\n5 3\n12 13 18 20 27216\n",
"output": "10101\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/CHEFSTEP"
} | vfc_3522 | false | false | false | false | false |
apps | verifiable_code | 1171 | Solve the following coding problem using the programming language python:
Roger recently built a circular race track with length K$K$. After hosting a few races, he realised that people do not come there to see the race itself, they come to see racers crash into each other (what's wrong with our generation…). After this realisation, Roger decided to hold a different kind of "races": he hired N$N$ racers (numbered 1$1$ through N$N$) whose task is to crash into each other.
At the beginning, for each valid i$i$, the i$i$-th racer is Xi$X_i$ metres away from the starting point of the track (measured in the clockwise direction) and driving in the direction Di$D_i$ (clockwise or counterclockwise). All racers move with the constant speed 1$1$ metre per second. The lengths of cars are negligible, but the track is only wide enough for one car, so whenever two cars have the same position along the track, they crash into each other and the direction of movement of each of these cars changes (from clockwise to counterclockwise and vice versa). The cars do not change the directions of their movement otherwise.
Since crashes reduce the lifetime of the racing cars, Roger sometimes wonders how many crashes happen. You should answer Q$Q$ queries. In each query, you are given an integer T$T$ and you should find the number of crashes that happen until T$T$ seconds have passed (inclusive).
-----Input-----
- The first line of the input contains three space-separated integers N$N$, Q$Q$ and K$K$.
- N$N$ lines follow. For each i$i$ (1≤i≤N$1 \le i \le N$), the i$i$-th of these lines contains two space-separated integers Di$D_i$ and Xi$X_i$, where Di=1$D_i = 1$ and Di=2$D_i = 2$ denote the clockwise and counterclockwise directions respectively.
- Each of the next Q$Q$ lines contain a single integer T$T$ describing a query.
-----Output-----
For each query, print a single line containing one integer — the number of crashes.
-----Constraints-----
- 1≤N≤105$1 \le N \le 10^5$
- 1≤Q≤1,000$1 \le Q \le 1,000$
- 1≤K≤1012$1 \le K \le 10^{12}$
- 1≤Di≤2$1 \le D_i \le 2$ for each valid i$i$
- 0≤Xi≤K−1$0 \le X_i \le K - 1$ for each valid i$i$
- X1,X2,…,XN$X_1, X_2, \ldots, X_N$ are pairwise distinct
- 0≤T≤1012$0 \le T \le 10^{12}$
-----Example Input-----
5 3 11
1 3
1 10
2 4
2 7
2 0
3
8
100
-----Example Output-----
4
10
110
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
from numba import njit
i8 = np.int64
@njit
def solve(a, b, t, K, N):
t1 = t // K
d = t % K * 2
# b が a から a + d の位置にあれば衝突する
x = 0
y = 0
ans = 0
for c in a:
while b[x] < c:
x += 1
while b[y] <= c + d:
y += 1
ans += y - x
ans += t1 * len(a) * (N - len(a)) * 2
return ans
def set_ini(DX, K):
a = DX[1][DX[0] == 1]
a = np.sort(a)
b = DX[1][DX[0] == 2]
b = np.sort(b)
b = np.hstack((b, b + K, b + 2 * K, [3 * K]))
return a, b
def main():
f = open('/dev/stdin', 'rb')
vin = np.fromstring(f.read(), i8, sep=' ')
N, Q, K = vin[0:3]
head = 3
DX = vin[head:head + 2*N].reshape(-1, 2).T
a, b = set_ini(DX, K)
head += 2 * N
T = vin[head: head + Q]
for t in T:
print(solve(a, b, t, K, N))
def __starting_point():
main()
__starting_point()
``` | {
"language": "python",
"test_cases": [
{
"input": "5 3 11\n1 3\n1 10\n2 4\n2 7\n2 0\n3\n8\n100\n",
"output": "4\n10\n110\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/CRSHIT"
} | vfc_3526 | false | false | false | false | false |
apps | verifiable_code | 1172 | Solve the following coding problem using the programming language python:
Chef has the string s of length n consisted of digits 4 and 7.
The string s is called balanced
if there exits such integer x (1 ≤ x ≤ n) that the number of digits 4 in substring s[1; x) is equal to the number of digits 7 in substring s(x; n],
where s[1; x) is the substring from the 1st digit to (x-1)th digit of s, and s(x; n] is the substring from the (x+1)th digit to nth digit of s.
For example, s = 747474 is a balanced string, because s[1; 4) = 747 has one 4 and s(4; 6] = 74 has one 7.
Note that x can be 1 or n and s[1; 1) and s(n; n] denote an empty string.
In one turn Chef can choose any pair of consecutive digits and swap them.
Find for Chef the total number of different balanced string that can be obtained from string s using any (even 0) number of turns.
Print the result modulo 1000000007.
-----Input-----
The first line of the input contains one integer T, the number of test cases.
Then T lines follow, each of which contains string s for the corresponding test.
-----Output-----
T lines, each of which contains single integer - the answer for the corresponding test modulo 109+7.
-----Constraints-----
1 ≤ T ≤ 10
1 ≤ n ≤ 5000
-----Example-----
Input:
2
47
4477
Output:
1
4
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
def Ncr(n,r):
if r<0:return 0
return factorial(n)/(factorial(n-r)*factorial(r))
def solve(m,n):
modulo=10**9+7
if m==n:
return (Ncr(2*n-1,n-1)+Ncr(2*n-2,n-2))%modulo
elif m>n:
return (Ncr(m+n,n)-Ncr(m+n-2,n-1))%modulo
else:
return (Ncr(m+n,m)-Ncr(m+n-2,m-1))%modulo
t=int(input())
for i in range(t):
inp=list(map(int,input()))
m=inp.count(4)
n=inp.count(7)
print(solve(m,n))
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n47\n4477\n\n\n",
"output": "1\n4\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/NOV12/problems/LUCKY9"
} | vfc_3530 | false | false | false | false | false |
apps | verifiable_code | 1173 | Solve the following coding problem using the programming language python:
Guddu was participating in a programming contest. He only had one problem left when his mother called him for dinner. Guddu is well aware how angry his mother could get if he was late for dinner and he did not want to sleep on an empty stomach, so he had to leave that last problem to you. Can you solve it on his behalf?
For a given sequence of positive integers $A_1, A_2, \ldots, A_N$, you are supposed to find the number of triples $(i, j, k)$ such that $1 \le i < j \le k \le N$ and
Ai⊕Ai+1⊕…⊕Aj−1=Aj⊕Aj+1⊕…⊕Ak,Ai⊕Ai+1⊕…⊕Aj−1=Aj⊕Aj+1⊕…⊕Ak,A_i \oplus A_{i+1} \oplus \ldots \oplus A_{j-1} = A_j \oplus A_{j+1} \oplus \ldots \oplus A_k \,,
where $\oplus$ denotes bitwise XOR.
-----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 number of triples.
-----Constraints-----
- $1 \le T \le 10$
- $2 \le N \le 10^5$
- $1 \le A_i \le 10^6$ for each valid $i$
-----Subtasks-----
Subtask #1 (20 points):
- $1 \le T \le 5$
- $1 \le N \le 100$
Subtask #2 (30 points):
- $1 \le T \le 5$
- $1 \le N \le 1,000$
Subtask #3 (50 points): original constraints
-----Example Input-----
1
3
5 2 7
-----Example Output-----
2
-----Explanation-----
Example case 1: The triples are $(1, 3, 3)$, since $5 \oplus 2 = 7$, and $(1, 2, 3)$, since $5 = 2 \oplus 7$.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
import itertools
from collections import defaultdict as dfd
def sumPairs(arr, n):
s = 0
for i in range(n-1,-1,-1):
s += i*arr[i]-(n-1-i)*arr[i]
return s
def subarrayXor(arr, n, m):
ans = 0
xorArr =[0 for _ in range(n)]
mp = dfd(list)
xorArr[0] = arr[0]
for i in range(1, n):
xorArr[i] = xorArr[i - 1] ^ arr[i]
for i in range(n):
mp[xorArr[i]].append(i)
a = sorted(mp.items())
#print(xorArr)
#print(a)
for i in a:
diffs=0
if(i[0]!=0):
l = len(i[1])-1
ans += sumPairs(i[1],len(i[1]))-((l*(l+1))//2)
else:
l = len(i[1])-1
ans += sumPairs(i[1],len(i[1]))-((l*(l+1))//2)
ans += sum(i[1])
return ans
for _ in range(int(input())):
n = int(input())
arr = list(map(int,input().split()))
print(subarrayXor(arr,len(arr),0))
``` | {
"language": "python",
"test_cases": [
{
"input": "1\n3\n5 2 7\n",
"output": "2\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/KS1"
} | vfc_3534 | false | false | false | false | false |
apps | verifiable_code | 1174 | Solve the following coding problem using the programming language python:
Chef has a sequence of N$N$ integers A1,A2,...,AN$A_1, A_2, ..., A_N$.
Chef thinks that a triplet of integers (i,j,k)$(i,j,k)$ is good if 1≤i<j<k≤N$1 \leq i < j < k \leq N$ and P$P$ in the following expression contains an odd number of ones in its binary representation:
P=[Ai<<(⌊log2(Aj)⌋+⌊log2(Ak)⌋+2)]+[Aj<<(⌊log2(Ak)⌋+1)]+Ak$P = [ A_i<< ( \lfloor \log_2(A_j) \rfloor + \lfloor \log_2(A_k) \rfloor + 2 ) ] + [A_j << ( \lfloor \log_2(A_k) \rfloor + 1) ] + A_k$
The <<$<<$ operator is called left shift, x<<y$x << y$ is defined as x⋅2y$x \cdot 2^y$.
Help the Chef finding the total number of good triplets modulo 109+7$10^9 + 7$.
-----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 of each test case contains N$N$ space-separated integers A1,A2,...,AN$A_1, A_2, ..., A_N$.
-----Output:-----
For each test case, print a single line containing one integer, the number of good triplets modulo 109+7$10^9+7$.
-----Constraints:-----
- 1≤T≤103$1 \leq T \leq 10^3$
- 1≤N≤105$1\leq N \leq 10^5$
- 1≤Ai≤109$1 \leq A_i \leq 10^9$
- The sum of N$N$ over all testcases is less than 106$10^6$
-----Sample Input:-----
1
4
1 1 2 3
-----Sample Output:-----
1
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
from math import *
t = int(input())
for _ in range(t):
n = int(input())
a = [int(d) for d in input().split()]
odd,even = 0,0
for i in range(n):
if bin(a[i]).count("1")%2 == 1:
odd += 1
else:
even +=1
total = 0
if odd >= 3 and even >= 2:
total += (odd*(odd-1)*(odd-2))//6
total += odd*(even*(even-1))//2
elif odd >= 3 and even < 2:
total += (odd*(odd-1)*(odd-2))//6
elif 0<odd < 3 and even >= 2:
total += odd*(even*(even-1))//2
print(total%(10**9+7))
``` | {
"language": "python",
"test_cases": [
{
"input": "1\n4\n1 1 2 3\n",
"output": "1\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/LOG_EQN"
} | vfc_3538 | false | false | false | false | false |
apps | verifiable_code | 1175 | Solve the following coding problem using the programming language python:
Oliver and Nova are true lovers. Inspite of knowing that Nova will die Oliver married her at the lake where they met. But they had a conflict about even and odd numbers. Nova likes the odd numbers and Oliver prefers even. One day they went to a fair where Oliver bought some square shaped marshmallows and Nova bought some round shaped. Then they decided to play a game. They will pick a natural number N . Nova will sum up the odd numbers from 1 to N and and she will notedown LCM of R(R is defined in the picture) and the sum she calculated before. And Oliver will sum up the even numbers from 1 to N and and he will notedown LCM of S(S is defined in the picture) and the sum he calculated before. You must use the ceil value of R and S.
Now whose LCM is strictly greater than the other will win.If both of their LCM is equal Nova will win because Oliver is afraid of Nova.
$N.B.$ define the value of pi with $acos(-1)$.
$N.B.$ Sum of all odd number and sum of all even number will not exceed 10^18.
-----Input:-----
The first line contains an integer $T$ — the number of test cases in the input. Next, T test cases are given, one per line.
Each test case is a positive integer $N$ .
-----Output:-----
Print T answers to the test cases.
In each test cases,
If Oliver wins the game, print "Nova's gonna kill me" (without quotes) .
If Nova wins the game, print "YESS(sunglass emo)" (without quotes) .
-----Constraints-----
- $1 \leq T \leq 2000$
- $1 \leq N \leq 1845271$
-----Sample Input:-----
1
111
-----Sample Output:-----
YESS(sunglass emo)
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 lcm(a, b):
return (a*b)//gcd(a, b)
def gcd(a, b):
if b == 0:
return a
return gcd(b, a%b)
for _ in range(int(input())):
n = int(input())
na = math.ceil((2*n)/math.acos(-1))
nb = ((n+1)//2)**2
nlcm = lcm(na, nb)
oa = math.ceil(n/2)
ob = (n//2)*(n//2+1)
olcm = lcm(oa, ob)
if olcm > nlcm:
print("Nova's gonna kill me")
else:
print("YESS(sunglass emo)")
# cook your dish here
``` | {
"language": "python",
"test_cases": [
{
"input": "1\n111\n",
"output": "YESS(sunglass emo)\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/NEWB2020/problems/CNFCT"
} | vfc_3542 | false | false | false | false | false |
apps | verifiable_code | 1176 | Solve the following coding problem using the programming language python:
There are $5$ cities in the country.
The map of the country is given below.
The tour starts from the red city.
Each road is associated with a character.
Initially, there is an empty string.
Every time a road has been travelled the character associated gets appended to the string.
At the green city either the string can be printed or the tour can be continued.
In the problem, you are given a string tell whether it is possible to print the string while following the rules of the country?
-----Input:-----
- First line will contain $T$, number of testcases. Then the testcases follow.
- Each testcase contains a single line of input, a string $ s $. The string consists only of $0's$ and $1's$.
-----Output:-----
For each testcase, output "YES" or "NO" depending on the input.
-----Constraints-----
-
$1 \leq T \leq 10000$
-
$1 \leq length of each string \leq 10000$
-
$ 1 \leq Summation length \leq 10^5$
-----Sample Input:-----
1
100
-----Sample Output:-----
NO
-----EXPLANATION:-----
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
for _ in range(int(input())):
s=input()
if len(s)<4:
print("NO")
else:
if s[-4:]=="1000":
print("YES")
else:
print("NO")
``` | {
"language": "python",
"test_cases": [
{
"input": "1\n100\n",
"output": "NO\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/ICM2006"
} | vfc_3546 | false | false | false | false | false |
apps | verifiable_code | 1177 | Solve the following coding problem using the programming language python:
Chef has N subordinates. In order to complete a very important order he will choose exactly K of them. He can't choose less than K since it will be not enough to complete the order in time. On the other hand if he chooses more than K subordinates he can't control them during the operation. Help him to find the number of ways he can choose the team to complete this very important order.
-----Input-----
The first line contains a single positive integer T <= 100, the number of test cases. T test cases follow. The only line of each test case contains two integers N and K, where 0 <= N, K < 2^64. It is guaranteed that the answer will be less than 2^64.
-----Output-----
For each test case, output a single line containing the number of ways to choose the required team.
-----Example-----
Input:
3
2 1
3 3
10 5
Output:
2
1
252
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
def nCr(n,k):
if(k>n):return 0
k=min(k,n-k)
num,den=1,1
for i in range(k):
num*=(n-i)
den*=(i+1)
return num/den
def Main():
for cases in range(int(input())):
a,b=[int(x) for x in input().split()]
print(nCr(a,b))
Main()
``` | {
"language": "python",
"test_cases": [
{
"input": "3\n2 1\n3 3\n10 5\n",
"output": "2\n1\n252\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/COOK06/problems/CHEFTEAM"
} | vfc_3550 | false | false | false | false | false |
apps | verifiable_code | 1178 | Solve the following coding problem using the programming language python:
Tonight, Chef would like to hold a party for his $N$ friends.
All friends are invited and they arrive at the party one by one in an arbitrary order. However, they have certain conditions — for each valid $i$, when the $i$-th friend arrives at the party and sees that at that point, strictly less than $A_i$ other people (excluding Chef) have joined the party, this friend leaves the party; otherwise, this friend joins the party.
Help Chef estimate how successful the party can be — find the maximum number of his friends who could join the party (for an optimal choice of the order of arrivals).
-----Input-----
- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
- The first line of each test case contains a single integer $N$.
- The second line contains $N$ space-separated integers $A_1, A_2, \ldots, A_N$.
-----Output-----
For each test case, print a single line containing one integer — the maximum number of Chef's friends who could join the party.
-----Constraints-----
- $1 \le T \le 1,000$
- $1 \le N \le 10^5$
- the sum of $N$ over all test cases does not exceed $10^6$
-----Example Input-----
3
2
0 0
6
3 1 0 0 5 5
3
1 2 3
-----Example Output-----
2
4
0
-----Explanation-----
Example case 1: Chef has two friends. Both of them do not require anyone else to be at the party before they join, so they will both definitely join the party.
Example case 2: At the beginning, friends $3$ and $4$ can arrive and join the party, since they do not require anyone else to be at the party before they join. After that, friend $2$ can arrive; this friend would see that there are two people at the party and therefore also join. Then, friend $1$ will also join, so in the end, there would be $4$ people attending the party.
Example case 3: No one will attend the party because each of Chef's friends will find zero people at the party and leave, regardless of the order in which they arrive.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
test=int(input())
for _ in range(test):
n=int(input())
ls=list(map(int,input().split()))
ls.sort()
s=0
for i in range(n):
if s>=ls[i]:
s=s+1
else:
break
print(s)
``` | {
"language": "python",
"test_cases": [
{
"input": "3\n2\n0 0\n6\n3 1 0 0 5 5\n3\n1 2 3\n",
"output": "2\n4\n0\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/CHFPARTY"
} | vfc_3554 | false | false | false | false | false |
apps | verifiable_code | 1179 | Solve the following coding problem using the programming language python:
You are given a positive integer $N$. Consider the sequence $S = (1, 2, \ldots, N)$. You should choose two elements of this sequence and swap them.
A swap is nice if there is an integer $M$ ($1 \le M < N$) such that the sum of the first $M$ elements of the resulting sequence is equal to the sum of its last $N-M$ elements. Find the number of nice swaps.
-----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 ― the number of nice swaps.
-----Constraints-----
- $1 \le T \le 10^6$
- $1 \le N \le 10^9$
-----Subtasks-----
Subtask #1 (10 points):
- $T \le 10$
- $N \le 10^3$
Subtask #2 (30 points):
- $T \le 10$
- $N \le 10^6$
Subtask #3 (60 points): original constraints
-----Example Input-----
5
1
2
3
4
7
-----Example Output-----
0
0
2
2
3
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
# cook your dish here
from math import sqrt
for _ in range(int(input())):
n=int(input())
sum=(n*(n+1))//2
#print(sum)
if(sum%2!=0):
print(0)
continue
m=(int((sqrt(1+4*(sum)))-1)//2)
if(m*(m+1)//2==sum//2):
print((((m-1)*m)//2)+n-m+((n-m-1)*(n-m))//2)
else:
print(n-m)
``` | {
"language": "python",
"test_cases": [
{
"input": "5\n1\n2\n3\n4\n7\n",
"output": "0\n0\n2\n2\n3\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/CHFNSWAP"
} | vfc_3558 | false | false | false | false | false |
apps | verifiable_code | 1180 | Solve the following coding problem using the programming language python:
You are playing a Billiards-like game on an $N \times N$ table, which has its four corners at the points $\{(0, 0), (0, N), (N, 0),$ and $(N, N)\}$. You start from a coordinate $(x,y)$, $(0 < x < N, 0 < y < N)$ and shoot the ball at an angle $45^{\circ}$ with the horizontal. On hitting the sides, the ball continues to move with the same velocity and ensuring that the angle of incidence is equal to the angle of reflection with the normal, i.e, it is reflected with zero frictional loss. On hitting either of the four corners, the ball stops there and doesn’t move any further.
Find the coordinates of the point of collision, when the ball hits the sides for the $K^{th}$ time. If the ball stops before hitting the sides $K$ times, find the coordinates of the corner point where the ball stopped instead.
-----Input:-----
- The first line of the input contains an integer $T$, the number of testcases.
- Each testcase contains a single line of input, which has four space separated integers - $N$, $K$, $x$, $y$, denoting the size of the board, the number of collisions to report the answer for, and the starting coordinates.
-----Output:-----
For each testcase, print the coordinates of the ball when it hits the sides for the $K^{th}$ time, or the coordinates of the corner point if it stopped earlier.
-----Constraints-----
- $1 \leq T \leq 10^5$
- $2 \leq N \leq 10^9$
- $1 \leq K \leq 10^9$
-----Subtasks-----
- $30$ points : Sum of $K$ over all test cases $\le 10^7$
- $70$ points : Original constraints.
-----Sample Input:-----
2
5 5 4 4
5 2 3 1
-----Sample Output:-----
5 5
3 5
-----Explanation:-----
- Sample Case $1$ :
We are given a $5$ by $5$ board. We shoot the ball from coordinates $(4,4)$, and we need to find its coordinates after it has collided with sides $5$ times. However, after shooting, the ball goes directly to the corner $(5,5)$, and stops there. So we report the coordinates $(5,5)$.
- Sample Case $2$ :
We are given a $5$ by $5$ board. We shoot the ball from the coordinates $(3,1)$, and we need to find its coordinates after it has collided with the sides twice. After shooting, it first hits the right side at $(5,3)$, and then the top side at $(3,5)$. So, we report $(3,5)$.
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
b=0
N,K,x,y=map(int,input().split())
if x==y:
a=N
b=N
elif x>y:
if K%4==1:
a=N
b=y-x+N
elif K%4==2:
a=y-x+N
b=N
elif K%4==3:
a=0
b=x-y
else:
a=x-y
b=0
else:
if K%4==1:
a=x-y+N
b=N
elif K%4==2:
a=N
b=x-y+N
elif K%4==3:
a=y-x
b=0
else:
a=0
b=y-x
print(a,b)
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n5 5 4 4\n5 2 3 1\n",
"output": "5 5\n3 5\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/BILLRD"
} | vfc_3562 | false | false | false | false | false |
apps | verifiable_code | 1181 | Solve the following coding problem using the programming language python:
Chef has a natural number N. Cheffina challenges chef to check whether the given number is divisible by the sum of its digits or not. If the given number is divisible then print "Yes" else "No".
-----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
16
27
-----Sample Output:-----
No
Yes
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
import sys,io,os,math
from math import ceil,log,gcd,inf
from itertools import permutations
mod=1000000007
mod1=998244353
def printlist(n):
sys.stdout.write(" ".join(map(str,n)) + "\n")
printf=lambda n:sys.stdout.write(str(n)+"\n")
def printns(n):
sys.stdout.write(str(n))
def intinp():
return int(sys.stdin.readline())
def strinp():
return sys.stdin.readline()
def arrinp():
return list(map(int,sys.stdin.readline().strip().split()))
def mulinp():
return list(map(int,sys.stdin.readline().strip().split()))
def flush():
return sys.stdout.flush()
def power_two(x):
return (1<<x)
def lcm(a,b):
return a*b//gcd(a,b)
def solve():
n=intinp()
ans=str(n)
count=0
for i in ans:
count+=int(i)
if(n%count==0):
print('Yes')
return 0
print('No')
def main():
tc=intinp()
while(tc):
solve()
tc-=1
main()
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n16\n27\n",
"output": "No\nYes\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/PEND2020/problems/ANITGUY9"
} | vfc_3566 | false | false | false | false | false |
apps | verifiable_code | 1182 | Solve the following coding problem using the programming language python:
Gorodetskiy is a university student. He is really good at math and really likes solving engaging math problems. In the last exam, his professor gave him really hard math problems to solve, but Gorodetskiy could not solve them and failed the exam, so the professor told him: "These problems are a piece of cake, you should know them from school!" Here is one of the problems from the exam - you can decide if it really was an easy problem or not.
You are given a positive integer $M$. Let's call a positive integer $A$ an interesting number if there is at least one integer $B$ ($A \le B$) such that $A \cdot B$ is divisible by $M$ and $\frac{A \cdot B}{M} = A+B$.
Find all interesting numbers. Let's denote the number of such integers by $K$; it is guaranteed that $K \le 3*10^5$.
-----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 $M$.
-----Output-----
For each test case:
- First, print a line containing a single integer $K$.
- Then, print $K$ lines. For each valid $i$, the $i$-th of these lines should contain a single integer ― the $i$-th interesting number in increasing order.
-----Constraints-----
- $1 \le T \le 10$
- $1 \le M \le 10^{14}$
-----Subtasks-----
Subtask #1 (20 points): $1 \le M \le 100$
Subtask #2 (20 points): $1 \le M \le 10^7$
Subtask #3 (60 points): original constraints
-----Example Input-----
2
3
6
-----Example Output-----
2
4
6
5
7
8
9
10
12
-----Explanation-----
Example case 1: There are two interesting numbers, $4$ and $6$. For $A = 4$, we can choose $B = 12$ and for $A = 6$, we can choose $B = 6$.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
def interesting_nums(m):
nums = []
for x in range(m + 1, 2 * m + 1):
if x * m % (x - m) == 0:
nums.append(x)
return nums
def main():
T = int(input())
for _ in range(T):
num_list = interesting_nums(int(input()))
print(len(num_list))
for num in num_list:
print(num)
main()
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n3\n6\n",
"output": "2\n4\n6\n5\n7\n8\n9\n10\n12\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/DRMP"
} | vfc_3570 | false | false | false | false | false |
apps | verifiable_code | 1183 | Solve the following coding problem using the programming language python:
Problem description.
This problem is simple and will introduce you to the Dynamic Programming.
You will be given an array and a key value.
You will have to find out the occurrences of the key value depending upon the query using Brute Force and Top Down Dynamic Programming.
-----Brute-Force: -----
You will check the query, and calculate the occurrences.
-----DP: -----
You will check the query; check whether the memoized solution is already available.
If the memoized solution is available, no need to calculate the number of occurrences again.
If the memoized solution is not available, then calculate the number of occurrences and memoize it for future use.
-----Pseudo Code for DP:-----
countOccurences(key,from):
if (from = size of array) then
return 0
endif
if dp[from] is availabe then
return dp[from]
endif
if( array[from] == key) then
dp[from] = 1+countOccurences(key,from+1)
else
dp[from] = countOccurences(key,from+1)
endif
return dp[from]
-----Input:-----
The first line of input is the number of test cases (t).
The first line of each test case is the number of array elements (n).
The next will contain n space separated integers.
The next line will have the key element (k).
The next will have number of queries (q).
The next q lines will contain an integer A such that 0<=A < n.
You have to find out the number of occurrences from a to end of the array using both brute force and DP.
Everything will fit into the range of int.
-----Output:-----
For each test case, the output will have q lines with 3 space separated integers.
The first will be the number of occurrences, other will be the loop count/function calls,
using brute force and the last will be the number of loop count/function calls using DP.
-----Sample Input:-----
1
10
1 2 3 1 2 3 1 2 3 1
3
5
2
4
6
8
2
-----Sample output:-----
3 8 9
2 6 1
1 4 1
1 2 1
3 8 1
-----Explanation:-----
For the first query, we have to find the number of occurrences of 3 from index 2.
Using the brute force, the loop will check each element from index 2 to 9. Thus the loop count is 8.
Using DP, the method countOccurences(key,from) will be called like this :
countOccurences(3,2)->countOccurences(3,3)->countOccurences(3,4)->countOccurences(3,5)
->countOccurences(3,6)->countOccurences(3,7)->countOccurences(3,8)
->countOccurences(3,9)->countOccurences(3,10).
When the countOccurences(3,10) is called, it will return 0. Total 9 function calls.
For the second query, the brute force will do the same as above.
But the DP will check whether solution for countOccurences(3,4) is available or not.
As it was calculated while solving the first query, it won’t solve it again and will directly give the answer.
Total 1 function calls.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
for __ in range(eval(input())):
x = eval(input())
a = list(map(int,input().split()))
key = eval(input())
query = eval(input())
maxvisited = x #maximum visted value
j = x-1
ans = []
val = 0
while j>=0:
if a[j]==key:
ans.append(val+1)
val = val +1
else: ans.append(val)
j-=1
ans.reverse()
#print ans
for ii in range(query):
W = eval(input())
print(ans[W], end=' ')
print(x-W, end=' ')
#print maxvisited, W
if maxvisited>W:
print(maxvisited-W+1)
maxvisited = W
else: print('1')
``` | {
"language": "python",
"test_cases": [
{
"input": "1\n10\n1 2 3 1 2 3 1 2 3 1\n3\n5\n2\n4\n6\n8\n2\n\n",
"output": "3 8 9\n2 6 1\n1 4 1\n1 2 1\n3 8 1\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/AIPC2015/problems/AN01"
} | vfc_3574 | false | false | false | false | false |
apps | verifiable_code | 1184 | Solve the following coding problem using the programming language python:
Chef's friend Alex runs a movie theatre. Due to the increasing number of platforms for watching movies online, his business is not running well. As a friend, Alex asked Chef to help him maximise his profits. Since Chef is a busy person, he needs your help to support his friend Alex.
Alex's theatre has four showtimes: 12 PM, 3 PM, 6 PM and 9 PM. He has four movies which he would like to play ― let's call them A, B, C and D. Each of these movies must be played exactly once and all four must be played at different showtimes. For each showtime, the price of a ticket must be one of the following: Rs 25, Rs 50, Rs 75 or Rs 100. The prices of tickets for different showtimes must also be different.
Through his app, Alex receives various requests from his customers. Each request has the form "I want to watch this movie at this showtime". Let's assume that the number of people who come to watch a movie at a given showtime is the same as the number of requests for that movie at that showtime.
It is not necessary to accommodate everyone's requests ― Alex just wants to earn the maximum amount of money. There is no restriction on the capacity of the theatre. However, for each movie that is not watched by anyone, Alex would suffer a loss of Rs 100 (deducted from the profit).
You are given $N$ requests Alex received during one day. Find the maximum amount of money he can earn on that day by choosing when to play which movies and with which prices.
-----Input-----
- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
- The first line of each test case contains a single integer $N$.
- $N$ lines follow. Each of these lines contains a character $m$, followed by a space and an integer $t$, describing a request to see the movie $m$ at the showtime $t$.
-----Output-----
For each test case, print a single line containing one integer ― the maximum profit Alex can earn (possibly negative).
Finally, print a line containing one integer ― the total profit over all test cases, i.e. over $T$ days.
-----Constraints-----
- $1 \le T \le 150$
- $0 \le N \le 100$
- $m$ is 'A', 'B', 'C' or 'D'
- $t$ is $12$, $3$, $6$ or $9$
-----Subtasks-----
Subtask #1 (30 points): it is possible to fulfill all requests
Subtask #2 (70 points): original constraints
-----Example Input-----
5
12
A 3
B 12
C 6
A 9
B 12
C 12
D 3
B 9
D 3
B 12
B 9
C 6
7
A 9
A 9
B 6
C 3
D 12
A 9
B 6
2
A 9
B 6
1
D 12
0
-----Example Output-----
575
525
-25
-200
-400
475
-----Explanation-----
Example case 1: The following table shows the number of people that want to watch the movies at the given showtimes: 12 3 6 9 A 0 1 0 1 B 3 0 0 2 C 1 0 2 0 D 0 2 0 0
The maximum number of requests was sent for movie B at 12 PM. Therefore, we play this movie at this time and the tickets cost Rs 100. Next, we play movie D at 3 PM with ticket price Rs 75 and movie C at 6 PM with ticket price Rs 50. Finally, we have a slot for 9 PM and the only movie we can play at that time now is movie A, with ticket price Rs 25. The total profit is $3 \cdot 100 + 2 \cdot 75 + 2 \cdot 50 + 1 \cdot 25 = 300 + 150 + 100 + 25 = 575$. Since each movie was watched by at least one person, there is no additional loss.
Example case 2: Just like above, we show the requests in a table: 12 3 6 9 A 0 0 0 3 B 0 0 2 0 C 0 1 0 0 D 1 0 0 0
The optimal solution is to play movie A at 9 PM, movie B at 6 PM, movie C at 3 PM and movie D at 12 PM, with decreasing ticket prices in this order. The profit is $3 \cdot 100 + 2 \cdot 75 + 1 \cdot 50 + 1 \cdot 25 = 300+150+50+25 = 525$.
Example case 3: Again, we show the requests in a table: 12 3 6 9 A 0 0 0 1 B 0 0 1 0 C 0 0 0 0 D 0 0 0 0
The optimal solution is to play movie A at 9 PM with ticket price Rs 100, movie B at 6 PM with ticket price Rs 75 and the remaining two movies in any order at 12 PM and 3 PM ― either way, there will be nobody watching them. We earn $1 \cdot 100 + 1 \cdot 75 = 175$, but we have to deduct Rs 200, so the resulting profit is $175 - 200 = -25$.
Example case 4: The optimal solution is to play movie D at 12 PM; the other three movies go unattended. We have to deduct Rs 300, so the profit is $1 \cdot 100 - 300 = -200$.
Example case 5: Since there are no requests for any movie at any time, all movies go unattended and Alex just suffers a loss of Rs 400.
The total profit for all 5 days is $575+525-25-200-400 = 475$.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
from itertools import permutations
C = list(permutations(['A','B','C','D']))
V = list(permutations([3,6,9,12]))
P = list(permutations([25,50,75,100]))
R = []
def test():
d = {}
n = int(input())
for i in C[0]:
for j in V[0]:
d[i+str(j)] = 0
for i in range(n):
x,y = input().split()
d[x+y] += 1
ans = -1000000000
for i in C:
for j in V:
for k in P:
c = 0
for l in range(4):
if d[i[l]+str(j[l])] == 0:
c -= 100
else:
c += (d[i[l]+str(j[l])]*k[l])
ans = max(ans,c)
R.append(ans)
print(ans)
def __starting_point():
t = int(input())
for i in range(t):
test()
print(sum(R))
__starting_point()
``` | {
"language": "python",
"test_cases": [
{
"input": "5\n12\nA 3\nB 12\nC 6\nA 9\nB 12\nC 12\nD 3\nB 9\nD 3\nB 12\nB 9\nC 6\n7\nA 9\nA 9\nB 6\nC 3\nD 12\nA 9\nB 6\n2\nA 9\nB 6\n1\nD 12\n0\n",
"output": "575\n525\n-25\n-200\n-400\n475\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/THEATRE"
} | vfc_3578 | false | false | false | false | false |
apps | verifiable_code | 1185 | Solve the following coding problem using the programming language python:
Taru likes reading. Every month he gets a copy of the magazine "BIT". The magazine contains information about the latest advancements in technology. Taru
reads the book at night and writes the page number to which he has read on a piece of paper so that he can continue from there the next day. But sometimes
the page number is not printed or is so dull that it is unreadable. To make matters worse Taru's brother who is really naughty tears of some of the pages of
the Magazine and throws them in the dustbin. He remembers the number of leaves he had torn but he does not remember which page numbers got removed. When Taru
finds this out he is furious and wants to beat him up. His brother apologizes, and says he won't ever do this again. But Taru did not want to be easy on him
and he says "I will leave you only if you help me find the answer to this. I will tell you how many pages (Printed sides) were there in the Magazine plus the
pages on which the page numbers were not printed. You already know the number of leaves you tore (T). Can you tell me the expected sum of the page numbers
left in the Magazine?" Taru's brother replied "huh!! This is a coding problem". Please help Taru's brother.
Note: The magazine is like a standard book with all odd page numbers in front and the successive even page number on its back. If the book contains 6 pages,
Page number 1 and Page number 2 are front and back respectively. Tearing a leaf removes both the front and back page numbers.
-----Input-----
The first line contains the number of test cases t. 3t lines follow. The first line of each test case contains the number of pages (printed sides) in the
book. The second line's first integer is F, F integers follow which tell us the numbers of the page numbers not printed. The third line contains a single integer telling us the number of leaves Taru's brother tore.
-----Output-----
Output one real number correct up to 4 decimal digits which is equal to the expected sum of the page numbers left in the book.
-----Constraints-----
Number of printed Sides<=2000. All other values abide by the number of printed sides.
-----Example-----
Input:
2
10
2 1 2
2
10
1 8
0
Output:
31.2000
47.0000
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
import sys
rl=sys.stdin.readline
T=int(rl())
for t in range(T):
P=int(rl())
T=(P+1)//2
F=list(map(int,rl().split()))[1:]
numtorn=int(rl())
t=sum(range(1,P+1))-sum(F)
K=T-numtorn
print('%.4f' % (t*K/float(T)))
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n10\n2 1 2\n2\n10\n1 8\n0\n",
"output": "31.2000\n47.0000\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/SEPT11/problems/TRMAG"
} | vfc_3582 | false | false | false | false | false |
Subsets and Splits