source
stringclasses 1
value | task_type
stringclasses 1
value | in_source_id
stringlengths 1
4
| problem
stringlengths 488
6.07k
| gold_standard_solution
stringlengths 19
30.1k
| verification_info
dict | metadata
dict | problem_id
stringlengths 5
9
|
|---|---|---|---|---|---|---|---|
apps | verifiable_code | 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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
apps | verifiable_code | 1186 | Solve the following coding problem using the programming language python:
Bhallaladeva was an evil king who ruled the kingdom of Maahishmati. He wanted to erect a 100ft golden statue of himself and he looted gold from several places for this. He even looted his own people, by using the following unfair strategy:
There are N houses in Maahishmati, and the ith house has Ai gold plates. Each gold plate costs exactly 1 Nimbda, which is the unit of currency in the kingdom of Maahishmati. Bhallaladeva would choose an integer K, and loots all the houses in several steps. In each step:
- He would choose a house i which hasn't been looted yet, pay the owner exactly Ai Nimbdas, and take away all the gold plates in that house (Hence, he also ends up looting this house).
- He would now choose atmost K houses which haven't been looted yet and take away all the gold plates from these houses without paying a single Nimbda (Yes, he takes all of them for free).
He repeats the above steps until all the N houses have been looted. Your task is to devise a strategy for Bhallaladeva to loot the houses in some order, so that the number of nimbdas he has to pay is minimium. You'll also be given multiple values of K (Q of them to be precise), and you need to find the minimum number of nimbdas for each of these values.
-----Input-----
The first line of input consists of a single integer N denoting the number of houses in Maahishmati. The second line of input consists of N space separated integers denoting A1, A2, ..., AN, where Ai denotes the number of gold plates in the ith house. The third line of input consists of a single integer Q denoting the number of values of K to follow. Each of the following Q lines consist of a single integer, where the value on the ith line denotes the value of K for the ith query.
-----Output-----
Output exactly Q integers on separate lines, where the output on the ith line denotes the answer for the ith value of K.
-----Constraints-----
- 1 ≤ N ≤ 105
- 1 ≤ Q ≤ 105
- 0 ≤ K ≤ N-1
- 1 ≤ Ai ≤ 104
-----Example-----
Input:
4
3 2 1 4
2
0
2
Output:
10
3
-----Explanation-----
For the first query, K = 0. Hence, Bhallaladeva cannot take gold plates from any of the houses for free. It will cost him 3 + 2 + 1 + 4 = 10 nimbdas.
For the second query, K = 2. In the first step Bhallaladeva can pay 2 nimbdas for gold plates in house number 2, and take the gold in houses 1 and 4 for free (Note that house 1 has 3 gold plates and house 4 has 4 gold plates). Now, he has looted houses 1, 2 & 4. Now in the second step, he loots house 3, by paying 1 nimbda. Hence, the total cost = 1 + 2 = 3. Note that there might be multiple ways to achieve the minimum cost, and we have explained only one of them.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
import math
n = int(input())
a = sorted(map(int,input().split()))
l = [0]*n
for i in range(n):
l[i] = a[i] + l[i-1]
for q in range(int(input())):
print(l[int(math.ceil(float(n)/(int(input())+1)))-1])
``` | {
"language": "python",
"test_cases": [
{
"input": "4\n3 2 1 4\n2\n0\n2\n",
"output": "10\n3\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/AMR15ROL/problems/AMR15D"
} | vfc_3586 |
apps | verifiable_code | 1187 | Solve the following coding problem using the programming language python:
Chef wants to select a subset $S$ of the set $\{1, 2, \ldots, N\}$ such that there are no two integers $x, y \in S$ which satisfy $\frac{x}{y} = M$.
Help Chef find the maximum size of a subset $S$ he can choose and the number of ways in which he can choose a subset $S$ with this maximum size. Since the number of ways to choose $S$ can be very large, calculate it modulo $998,244,353$.
-----Input-----
- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
- The first and only line of each test case contains two space-separated integers $N$ and $M$.
-----Output-----
For each test case, print a single line containing two space-separated integers ― the maximum size of a subset Chef can choose and the number of ways to choose a subset with this maximum size modulo $998,244,353$. Note that only the number of ways to choose a subset should be printed modulo $998,244,353$.
-----Constraints-----
- $1 \le T \le 10,000$
- $2 \le M \le N \le 10^{18}$
-----Example Input-----
3
5 2
10 2
100 3
-----Example Output-----
4 1
6 12
76 49152
-----Explanation-----
Example case 1: The only subset $S$ with the maximum size which Chef can choose is $\{1, 3, 4, 5\}$.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
for _ in range(int(input())):
N,M = list(map(int,input().split()))
count,e,perm = 0,0,1
while(True):
lim,start = N//(M**e),N//(M**(e + 1)) + 1
num = lim - start + 1
divs = num//M
if((start + divs*M) <= lim):
r = (start+divs*M)%M
if(r == 0 or (r + (lim - (start + divs*M)) >= M)):
divs += 1
cmon = num - divs
if(e % 2 == 0):
count += cmon*((e+2)//2)
else:
count += cmon*(e//2 + 1)
perm = (perm * pow((e + 3)//2,cmon ,998244353))%998244353
e += 1
if(start == 1):
break
print(count,perm)
``` | {
"language": "python",
"test_cases": [
{
"input": "3\n5 2\n10 2\n100 3\n",
"output": "4 1\n6 12\n76 49152\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/BANQUNT"
} | vfc_3590 |
apps | verifiable_code | 1188 | Solve the following coding problem using the programming language python:
Chef is a private detective. He was asked to investigate a case of murder in the city of Frangton.
Chef arrived in Frangton to find out that the mafia was involved in the case. Chef spent some time watching for people that belong to the clan and was able to build a map of relationships between them. He knows that a mafia's organizational structure consists of a single Don, heading a hierarchical criminal organization. Each member reports exactly to one other member of the clan. It's obvious that there are no cycles in the reporting system of the mafia.
There are N people in the clan, for simplicity indexed from 1 to N, and Chef knows who each of them report to. Member i reports to member Ri.
Now, Chef needs to identfy all potential killers to continue his investigation. Having considerable knowledge about the mafia's activities, Chef knows that the killer must be a minor criminal, that is, one of the members who nobody reports to. Please find the list of potential killers for Chef. Since Don reports to nobody, his Ri will be equal to 0.
-----Input-----
The first line of input contains one integer N.
Next line has N space-separated integers, the ith integer denotes Ri — the person whom the ith member reports to.
-----Output-----
Output a list of space-separated integers in ascending order — the indices of potential killers.
-----Constraints-----
- 1 ≤ N ≤ 105
- 1 ≤ Ri ≤ N except for Don, whose Ri equals to 0.
- It is guaranteed that there are no cycles in the reporting structure.
-----Subtasks-----
- Subtask #1 [50 points]: N ≤ 10000
- Subtask #2 [50 points]: No additional constraints
-----Example-----
Input:
6
0 1 1 2 2 3
Output:
4 5 6
-----Explanation-----
The reporting structure:
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
n = eval(input())
r = list(map(int, input().split()))
tree = dict()
i = 1
for j in r:
c = tree.get(j)
if c:
tree[j].append(i)
else:
tree[j] = [i]
if not tree.get(i):
tree[i] = []
i += 1
s = []
for elem in tree:
if not tree[elem]:
s.append(str(elem))
print(' '.join(s))
``` | {
"language": "python",
"test_cases": [
{
"input": "6\n0 1 1 2 2 3\n",
"output": "4 5 6\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/FEB16/problems/CHEFDETE"
} | vfc_3594 |
apps | verifiable_code | 1189 | Solve the following coding problem using the programming language python:
You are given a sequence $A_1, A_2, \ldots, A_N$. For each $k$ ($1 \le k \le N$), let's define a function $f(k)$ in the following way:
- Consider a sequence $B_1, B_2, \ldots, B_N$, which is created by setting $A_k = 0$. Formally, $B_k = 0$ and $B_i = A_i$ for each valid $i \neq k$.
- $f(k)$ is the number of ways to split the sequence $B$ into two non-empty contiguous subsequences with equal sums.
Find the sum $S = f(1) + f(2) + \ldots + f(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.
- 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 sum $S$.
-----Constraints-----
- $1 \le T \le 10$
- $2 \le N \le 2 \cdot 10^5$
- $1 \le |A_i| \le 10^9$ for each valid $i$
-----Example Input-----
2
6
1 2 1 1 3 1
3
4 1 4
-----Example Output-----
6
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
def gt(num):
if num:
return num
return 0
for __ in range(int(stdin.readline().split()[0])):
n = int(stdin.readline().split()[0])
a = list(map(int, stdin.readline().split()))
cnta = dict()
cnta.setdefault(0)
cntb = dict()
cntb.setdefault(0)
for i in a:
cnta[i] = gt(cnta.get(i)) + 1
asum = 0
bsum = sum(a)
ans = 0
for i in range(n-1):
asum += a[i]
bsum -= a[i]
cnta[a[i]] = gt(cnta.get(a[i])) - 1
cntb[a[i]] = gt(cntb.get(a[i])) + 1
ans += gt(cnta.get(bsum-asum))
ans += gt(cntb.get(asum-bsum))
print(ans)
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n6\n1 2 1 1 3 1\n3\n4 1 4\n",
"output": "6\n2\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/CFINASUM"
} | vfc_3598 |
apps | verifiable_code | 1190 | Solve the following coding problem using the programming language python:
Tomya is a girl. She loves Chef Ciel very much.
Tomya like a positive integer p, and now she wants to get a receipt of Ciel's restaurant whose total price is exactly p.
The current menus of Ciel's restaurant are shown the following table.
Name of Menupriceeel flavored water1deep-fried eel bones2clear soup made with eel livers4grilled eel livers served with grated radish8savory egg custard with eel16eel fried rice (S)32eel fried rice (L)64grilled eel wrapped in cooked egg128eel curry rice256grilled eel over rice512deluxe grilled eel over rice1024eel full-course2048
Note that the i-th menu has the price 2i-1 (1 ≤ i ≤ 12).
Since Tomya is a pretty girl, she cannot eat a lot.
So please find the minimum number of menus whose total price is exactly p.
Note that if she orders the same menu twice, then it is considered as two menus are ordered. (See Explanations for details)
-----Input-----
The first line contains an integer T, the number of test cases.
Then T test cases follow.
Each test case contains an integer p.
-----Output-----
For each test case, print the minimum number of menus whose total price is exactly p.
-----Constraints-----
1 ≤ T ≤ 5
1 ≤ p ≤ 100000 (105)
There exists combinations of menus whose total price is exactly p.
-----Sample Input-----
4
10
256
255
4096
-----Sample Output-----
2
1
8
2
-----Explanations-----
In the first sample, examples of the menus whose total price is 10 are the following:
1+1+1+1+1+1+1+1+1+1 = 10 (10 menus)
1+1+1+1+1+1+1+1+2 = 10 (9 menus)
2+2+2+2+2 = 10 (5 menus)
2+4+4 = 10 (3 menus)
2+8 = 10 (2 menus)
Here the minimum number of menus is 2.
In the last sample, the optimal way is 2048+2048=4096 (2 menus).
Note that there is no menu whose price is 4096.
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):
n = int(input())
m=0
m=n//(2**11)
n%=(2**11)
while(n>0):
num=n%2
m+=num
n//=2
print(m)
t-=1
``` | {
"language": "python",
"test_cases": [
{
"input": "4\n10\n256\n255\n4096\n",
"output": "2\n1\n8\n2\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/CIELRCPT"
} | vfc_3602 |
apps | verifiable_code | 1191 | Solve the following coding problem using the programming language python:
Sandy is a professor at a very reputed institute. The institute mandates that all the lectures be communicated in English. As Sandy is not very good at English(or anything actually) the presentations he displays in class have a lot of spelling mistakes in them.
As you have a dictionary on you containing $N$ words in it, the responsibility of correctly deducing the misspelt word falls upon your shoulders. Sandy's presentation contains in them, $Q$ words which you $think$ are wrongly spelt. A word is misspelt if a $single$ letter in it is missing or is different from the corresponding correctly spelled word in your dictionary.
For each of the misspelt word in the presentation find out the corresponding correct word from your dictionary.
Note :
- For each misspelt word in Sandy's presentation, there exists one and only one correctly spelt word in your dictionary that corresponds to it.
- Out of the $Q$ misspelt words given to you, there might be some which are correctly spelt i.e., that word completely matches a word in your dictionary. (Give Sandy some credit, he's a teacher after all). For such words print the word corresponding to it in your dictionary.
- The maximum length of each string can be $L$.
-----Input:-----
- First line contains a single integer $T$ denoting the number of testcases. Then the testcases follow.
- The first line of each test case contains two space-separated integers $N, Q$ corresponding to the number of words in your dictionary and the number of misspelt word in Sandy's dictionary respectively.
- $N$ lines follow each containing a single string $S$ denoting a word in your dictionary.
- $Q$ lines follow each containing a single string $M$ denoting a misspelt word in Sandy's presentation.
-----Output:-----
In each testcase, for each of the $Q$ misspelt words, print a single word $S$ corresponding to the correctly spelt word in your dictionary.
-----Constraints-----
- $1 \leq T \leq 100$
- $1 \leq N \leq 200$
- $1 \leq Q \leq 200$
- $1 \leq L \leq 100$
- None of the words contain any spaces in them.
- Each letter in every word is in lower case.
-----Subtasks-----
-
Subtask 1 : 10 points
- $1 \leq N \leq 50$
- $1 \leq Q \leq 10$
-
Subtask 2 : 90 points
- Original Constraints
-----Sample Input:-----
1
5 2
szhbdvrngk
qzhxibnuec
jfsalpwfkospl
levjehdkjy
wdfhzgatuh
szhbdvcngk
qzhxbnuec
-----Sample Output:-----
szhbdvrngk
qzhxibnuec
-----EXPLANATION:-----
- In the first misspelt word $szhbdvcngk$, a single letter $c$ is different from the original word $szhbdvrngk$.
- The second misspelt word $qzhxbnuec$ is missing the letter $i$ that was in the original word $qzhxibnuec$.
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 difflib import get_close_matches
import sys, os
def closeMatches(patterns, word):
return get_close_matches(word, patterns, 1, 0.9)[0]
def get_string():
return sys.stdin.readline().strip()
def get_ints():
return map(int, sys.stdin.readline().strip().split())
ans = []
test = int(input())
for i in range(test):
n,q = get_ints()
#ans = []
n = int(n)
q = int(q)
patterns=[]
for j in range(n):
s = get_string()
patterns.append(s)
for j in range(q):
word = get_string()
ans.append(closeMatches(patterns, word))
for j in ans:
sys.stdout.write(j+"\n")
``` | {
"language": "python",
"test_cases": [
{
"input": "1\n5 2\nszhbdvrngk\nqzhxibnuec\njfsalpwfkospl\nlevjehdkjy\nwdfhzgatuh\nszhbdvcngk\nqzhxbnuec\n",
"output": "szhbdvrngk\nqzhxibnuec\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/PROC2020/problems/ENGRIS"
} | vfc_3606 |
apps | verifiable_code | 1192 | Solve the following coding problem using the programming language python:
You are given a sequence of integers $A_1, A_2, \ldots, A_N$. This sequence is circular ― for each valid $i$, the element $A_{i+1}$ follows after $A_i$, and the element $A_1$ follows after $A_N$.
You may insert any positive integers at any positions you choose in this sequence; let's denote the resulting sequence by $B$. This sequence is also circular. For each pair of its elements $B_s$ and $B_f$, let's denote the (non-circular) sequence created by starting at $B_s$ and moving from each element to the one that follows after it, until we reach $B_f$, by $B(s, f)$. This sequence includes the elements $B_s$ and $B_f$.
For each $K$ from $2$ to $N$ inclusive, find the smallest possible number of elements that need to be inserted into $A$ to form a sequence $B$ for which there is no subsequence $B(p, q)$ such that:
- The size of $B(p, q)$ is at least $K$.
- There is no pair of consecutive elements in $B(p, q)$ such that their GCD is equal to $1$.
-----Input-----
- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
- The first line of each test case contains a single integer $N$.
- The second line contains $N$ space-separated integers $A_1, A_2, \ldots, A_N$.
-----Output-----
For each test case, print a single line containing $N-1$ space-separated integers. For each $i$ ($1 \le i \le N-1$), the $i$-th of these integers should be the smallest number of inserted elements in a valid sequence $B$ for $K = i+1$.
-----Constraints-----
- $1 \le T \le 2,000$
- $2 \le N \le 10^5$
- $1 \le A_i \le 10^9$ for each valid $i$
- the sum of $N$ over all test cases does not exceed $2 \cdot 10^6$
-----Example Input-----
1
5
3 6 4 5 9
-----Example Output-----
3 1 1 0
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
from math import gcd
from itertools import groupby
def gcd_split(seq):
gcds= [int(gcd(a,b)==1) for a,b in zip(seq[1:],seq[:-1])]
gcds.append(int(gcd(seq[0],seq[-1])==1))
# print(gcds)
if max(gcds)==0:
return -1
else:
splits=[len(list(x))+1 for num,x in groupby(gcds) if num==0]
# print(splits)
if gcds[0]==gcds[-1]==0:
splits[0] += splits[-1]-1
splits = splits[:-1]
return splits
for _ in range(int(input())):
N=int(input())
A=[int(x) for x in input().split()]
split = gcd_split(A)
# print(split)
res=[]
if split!=-1:
for K in range(2,N+1):
temp=(x for x in split if x>=K)
ins = sum([(x//(K-1)-1 if x%(K-1)==0 else x//(K-1)) for x in temp])
if ins==0:
break
else:
res.append(ins)
else:
for K in range(2,N+1):
ins = N//(K-1)+(N%(K-1)>0)
if ins==0:
break
else:
res.append(ins)
res = res + [0]*(N-1 -len(res))
print(*res)
``` | {
"language": "python",
"test_cases": [
{
"input": "1\n5\n3 6 4 5 9\n",
"output": "3 1 1 0\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/MININS"
} | vfc_3610 |
apps | verifiable_code | 1193 | Solve the following coding problem using the programming language python:
There are $N$ robots who work for $Y$ days and on each day they
produce some toys .on some days a few robots are given rest.
So depending on the availability of robots owner has
made a time table which decides which robots will work on
the particular day.
Only contiguous robots must be selected as they can form
a link of communication among themselves.
Initially, all robots have the capacity of one toy.
On each day capacity for the chosen robot is updated i.e
capacity = capacity $+$$ ($minimum capacity of given range % $1000000007)$ .
After calculating the minimum capacity of a given range, compute
it as modulo 1000000007 ($10^9 + 7$).
After $Y$ days find the minimum capacity of the $N$ robots and compute it as modulo 1000000007 ($10^9 + 7$).
-----Input:-----
- First-line will contain $T$, the number of test cases. Then the test cases follow.
- Next Line contains a single integer N.
- Next Line contains a single integer Y.
- Next $Y$ lines contains l and r range of chosen robots .
-----Output:-----
For each testcase, output in a single line answer , the minimum capacity of the $N$ robots after $Y$ days and compute it as modulo 1000000007 ($10^9 + 7$) .
-----Constraints-----
- $1 \leq T \leq 100$
- $100 \leq N \leq 10^4$
- $200 \leq Y \leq 1000$
- $0<=l , r<=N-1$ , $l<=r$
-----Sample Input:-----
1
5
4
0 3
1 2
4 4
0 4
-----Sample Output:-----
4
-----EXPLANATION:-----
Initial capacity of the $5$ robots
1 1 1 1 1
Minimum in range [0,3] = 1
Update the capacity in the range [0,3]
Now capacity becomes,
Day 1 - 2 2 2 2 1
Similarly capacities changes for each day
Day 2 - 2 4 4 2 1
Day 3 - 2 4 4 2 2
Day 4 - 4 6 6 4 4
so after 4 days minimum capacity is $4$.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
MAX = 100005
tree = [0] * MAX;
lazy = [0] * MAX;
def updateRangeUtil(si, ss, se, us, ue, diff) :
if (lazy[si] != 0) :
tree[si] += lazy[si];
if (ss != se) :
lazy[si * 2 + 1] += lazy[si];
lazy[si * 2 + 2] += lazy[si];
lazy[si] = 0;
if (ss > se or ss > ue or se < us) :
return;
if (ss >= us and se <= ue) :
tree[si] += diff;
if (ss != se) :
lazy[si * 2 + 1] += diff;
lazy[si * 2 + 2] += diff;
return;
mid = (ss + se) // 2;
updateRangeUtil(si * 2 + 1, ss,mid, us, ue, diff);
updateRangeUtil(si * 2 + 2, mid + 1,se, us, ue, diff);
tree[si] = min(tree[si * 2 + 1],tree[si * 2 + 2]);
def updateRange(n, us, ue, diff) :
updateRangeUtil(0, 0, n - 1, us, ue, diff);
def getSumUtil(ss, se, qs, qe, si) :
if (lazy[si] != 0) :
tree[si] += lazy[si];
if (ss != se) :
lazy[si * 2 + 1] += lazy[si];
lazy[si * 2 + 2] += lazy[si];
lazy[si] = 0;
if (ss > se or ss > qe or se < qs) :
return 10e9;
if (ss >= qs and se <= qe) :
return tree[si];
mid = (ss + se) // 2;
return min(getSumUtil(ss, mid, qs, qe, 2 * si + 1),getSumUtil(mid + 1, se, qs, qe, 2 * si + 2));
def getSum(n, qs, qe) :
if (qs < 0 or qe > n - 1 or qs > qe) :
#print("Invalid Input", end = "");
return -1;
return getSumUtil(0, n - 1, qs, qe, 0);
def constructSTUtil(arr, ss, se, si) :
if (ss > se) :
return;
if (ss == se) :
tree[si] = arr[ss];
return;
mid = (ss + se) // 2;
constructSTUtil(arr, ss, mid, si * 2 + 1);
constructSTUtil(arr, mid + 1, se, si * 2 + 2);
tree[si] = min(tree[si * 2 + 1], tree[si * 2 + 2]);
def constructST(arr, n) :
constructSTUtil(arr, 0, n - 1, 0);
# Driver code
for _ in range(int(input())):
tree = [0] * MAX;
lazy = [0] * MAX;
n=int(input());
y=int(input());
arr=[1]*n;
constructST(arr, n);
for xyz in range(y):
l,r=list(map(int,input().split()));
updateRange(n, l, r, getSum(n, l, r)%1000000007);
print((getSum(n, 0, n-1)%1000000007));
``` | {
"language": "python",
"test_cases": [
{
"input": "1\n5\n4\n0 3\n1 2\n4 4\n0 4\n",
"output": "4\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/ENDE2020/problems/ENCDEC6"
} | vfc_3614 |
apps | verifiable_code | 1194 | Solve the following coding problem using the programming language python:
Toby has found a game to entertain himself.The game is like this:
You are in a coordinate system initially at (0,0) and you are given a sequence of steps which lead to your destination.The steps are given in the form of directions: ’U’ ,’D’ , ’L’ and ‘R’ for up, down, left and right respectively.If you are at position (x,y) then:
- U:move to (x,y+1)
- D:move to (x,y-1)
- L:move to (x-1,y)
- R:move to (x+1,y)
The sequence is provided as a string ‘s’ of characters where $s_i$ $(1 \leq i \leq N)$ is one of the direction character as mentioned above.An example of a sequence of steps is: UULRUDR
The destination according to this string is (1,2).
You want to remove maximum number of characters from the string such that the resulting string leads to the same destination as before.
For example in the example above we can remove characters at positions 1,3,4,6 and the resulting path will be UUR which will lead to the same destination i.e (1,2).so we reduced the number of steps by 4,and this is our score.
You need to get maximum score.
-----Input:-----
- First line will contain $T$, number of testcases. Then the testcases follow.
- First line of each testcase contains a single integer $N$,size of string.
- Second line of testcase contains a string $s$ of size $N$.
-----Output:-----
For each testcase, output a single line containing the maximum score possible.
-----Constraints-----
- $1 \leq T \leq 1000$
- $1 \leq N \leq 10^5$
-----Sample Input:-----
3
7
ULUDLLU
4
RUUR
4
LRLR
-----Sample Output:-----
2
0
4
-----EXPLANATION:-----
-
test case 1:
The final destination after moving according to the sequence is (-3,2).
One way is to remove characters at positions 3,4 and the resulting string will be ULLLU and destination still remains (-3,2).
-
test case 2: No character can be removed in this case.
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
try:
for _ in range(int(input())):
n=int(input())
s=input()
d1=dict(Counter(s))
u,d,r,l=0,0,0,0
if 'U' in d1:
u=d1['U']
else:
u=0
if 'D' in d1:
d=d1['D']
else:
d=0
if 'R' in d1:
r=d1['R']
else:
r=0
if 'L' in d1:
l=d1['L']
else:
l=0
x=0
y=0
if l==r:
x=0
elif l>r:
x=-(l-r)
elif r>l:
x=r-l
if u==d:
y=0
elif d>u:
y=-(d-u)
elif u>d:
y=u-d
# print(x,y)
if x==0 and y==0:
print(n)
continue
print(n-(abs(x)+abs(y)))
except:
pass
``` | {
"language": "python",
"test_cases": [
{
"input": "3\n7\nULUDLLU\n4\nRUUR\n4\nLRLR\n",
"output": "2\n0\n4\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/CSEP2020/problems/TOBY"
} | vfc_3618 |
apps | verifiable_code | 1195 | Solve the following coding problem using the programming language python:
Chefland has all the cities on a straight line. There are $N$ cities in Chefland numbered $1$ to $N$. City $i$ is located at coordinate $x_i$ on the x-axis. Guru wants to travel from city $A$ to city $B$. He starts at time t=0. He has following choices to travel.
- He can walk $1$ metre in $P$ secs.
- There is a train that travels from city $C$ to city $D$ which travels $1$ metre in $Q$ secs which starts at time t=$Y$ secs. Guru can take the train only at city $C$ and leave the train only at city $D$.
Can you help Guru find the minimum time he will need to travel from city $A$ to $B$. Note that you cannot board the train after time t =$Y$.
-----Input:-----
- First line will contain $T$, number of testcases. Then the testcases follow.
- First line of each testcase contains eight space separated integers $N, A, B, C, D, P, Q, Y $.
- Second line of each testcase contains $N$ space-separated integers with the $i$-th integer representing $x_i$.
-----Output:-----
For each testcase, output in a single line containing the minimum travel time.
-----Constraints-----
- $1 \leq T \leq 300$
- $2 \leq N \leq 300$
- $-1000 \leq x_i \leq 1000$
- $0 \leq Y \leq 100000$
- $1 \leq A,B,C,D \leq n $
- $A \neq B$
- $C \neq D$
- $1 \leq P, Q \leq 100$
- $x_i < x_j$ if $i < j$
-----Sample Input:-----
1
4 1 3 2 4 3 2 4
1 2 3 4
-----Sample Output:-----
6
-----EXPLANATION:-----
Guru can walk directly in 6 secs.
If Guru takes train, then he will need atleast 11 secs.
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,a,b,c,d,p,q,y=list(map(int,input().split()))
l=list(map(int,input().split()))
ans = abs((l[b-1]-l[a-1]))*p
x=abs(l[c-1]-l[a-1])*p
if x<=y:
x=y+abs(l[d-1]-l[c-1])*q+abs(l[b-1]-l[d-1])*p
ans=min(ans,x)
print(ans)
``` | {
"language": "python",
"test_cases": [
{
"input": "1\n4 1 3 2 4 3 2 4\n1 2 3 4\n",
"output": "6\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/WALKFAST"
} | vfc_3622 |
apps | verifiable_code | 1196 | Solve the following coding problem using the programming language python:
Every college has a stud−max$stud-max$ buoy. JGEC$JGEC$ has its own Atul$Atul$ who loves to impress everyone with his smile. A presentation is going on at the auditorium where there are N$N$ rows of M$M$ chairs with people sitting on it. Everyone votes for Atul's presentation skills, but Atul is interested in knowing the maximum$maximum$ amount of vote that he receives either taking K$K$ people vertically$vertically$ or horizontally$horizontally$. Atul$Atul$, however, wants to finish up the presentation party soon, hence asks for your help so that he can wrap up things faster.
-----Input:-----
- First line will contain T$T$, number of test cases. Then the test cases follow.
- Each testcase contains of a single line of input, three integers N$N$, M$M$ and K$K$.
- N lines follow, where every line contains M numbers$numbers$ denoting the size of the sugar cube
-----Output:-----
For each test case, output in a single line the maximum votes Atul can get.
-----Constraints-----
- 1≤T≤$1 \leq T \leq $5
- 1≤N,M≤500$1 \leq N,M \leq 500$
- K≤min(N,M)$K \leq min(N,M)$
- 1≤numbers≤109$1 \leq numbers \leq 10^9$
-----Sample Input:-----
1
4 4 3
1 4 5 7
2 3 8 6
1 4 8 9
5 1 5 6
-----Sample Output:-----
22
-----EXPLANATION:-----
If Atul starts counting votes from (1,4), then he can take the 3 consecutive elements vertically downwards and those are 7,6 and 9 which is the maximum sum possible.
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):
q = input().split()
n = int(q[0])
m = int(q[1])
k = int(q[2])
sumax = 0
b = []
for j in range(n):
a = [int(k) for k in input().split()]
b = b + [a]
for j in range(n):
su = 0
for x in range(k):
su = su +b[j][x]
if su > sumax:
sumax = su
for a in range(1, m-k+1):
su = su - b[j][a-1] +b[j][k+a-1]
if su > sumax:
sumax = su
for j in range(m):
su = 0
for x in range(k):
su = su + b[x][j]
if su > sumax:
sumax = su
for a in range(1, n-k+1):
su = su - b[a-1][j] + b[a+k-1][j]
if su > sumax:
sumax = su
print(sumax)
``` | {
"language": "python",
"test_cases": [
{
"input": "1\n4 4 3\n1 4 5 7\n2 3 8 6\n1 4 8 9\n5 1 5 6\n",
"output": "22\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/AARA2018/problems/ARMBH2"
} | vfc_3626 |
apps | verifiable_code | 1197 | Solve the following coding problem using the programming language python:
Chef loves saving money and he trusts none other bank than State Bank of Chefland. Unsurprisingly, the employees like giving a hard time to their customers. But instead of asking them to stand them in long queues, they have weird way of accepting money.
Chef did his homework and found that the bank only accepts the money in coins such that the sum of the denomination with any previously deposited coin OR itself can't be obtained by summing any two coins OR double of any coin deposited before. Considering it all, he decided to start with $1$ Chefland rupee and he would keep choosing smallest possible denominations upto $N$ coins. Since chef is busy with his cooking, can you find out the $N$ denomination of coins chef would have to take to the bank? Also find the total sum of money of those $N$ coins.
-----Input:-----
- First line has a single integer $T$ i.e. number of testcases.
- $T$ lines followed, would have a single integer $N$ i.e. the number of coins the chef is taking.
-----Output:-----
- Output for $i$-th testcase ($1 ≤ i ≤ T$) would have 2 lines.
- First line would contain $N$ integers i.e. the denomination of coins chef would deposit to the bank.
- Second line would contain a single integer i.e. the sum of all the coins chef would deposit.
-----Constraints:-----
- $1 ≤ T ≤ 700$
- $1 ≤ N ≤ 700$
-----Subtasks:-----
- $20$ points: $1 ≤ T, N ≤ 80$
- $70$ points: $1 ≤ T, N ≤ 500$
- $10$ points: $1 ≤ T, N ≤ 700$
-----Sample Input:-----
4
1
2
3
4
-----Sample Output:-----
1
1
1 2
3
1 2 4
7
1 2 4 8
15
-----Explanation:-----
For testcase 1: First coin is stated to be 1, hence for $N$ = 1, 1 is the answer.
For testcase 2: Since chef chooses the lowest possible denomination for each $i$-th coin upto $N$ coins, second coin would be 2. Only sum possible with N = 1 would be 1+1 = 2. For N = 2, $\{1+2, 2+2\}$ $\neq$ $2$.
For testcase 3: With first two coins being 1 and 2, next coin couldn't be 3 because 3+1 = 2+2, but $\{4+1, 4+2, 4+4\}$ $\neq$ $\{1+1, 1+2, 2+2\}$
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
lst=[1, 2, 4, 8, 13, 21, 31, 45, 66, 81, 97, 123, 148, 182, 204, 252, 290, 361, 401, 475, 565, 593, 662, 775, 822, 916, 970, 1016, 1159, 1312, 1395, 1523, 1572, 1821, 1896, 2029, 2254, 2379, 2510, 2780, 2925, 3155, 3354, 3591, 3797, 3998, 4297, 4433, 4779, 4851, 5123, 5243, 5298, 5751, 5998, 6374, 6801, 6925, 7460, 7547, 7789, 8220, 8503, 8730, 8942, 9882, 10200, 10587, 10898, 11289, 11614, 11876, 12034, 12931, 13394, 14047, 14534, 14901, 15166, 15688, 15972, 16619, 17355, 17932, 18845, 19071, 19631, 19670, 20722, 21948, 22526, 23291, 23564, 23881, 24596, 24768, 25631, 26037, 26255, 27219, 28566, 29775, 30094, 31311, 32217, 32620, 32912, 34277, 35330, 35469, 36204, 38647, 39160, 39223, 39943, 40800, 41882, 42549, 43394, 44879, 45907, 47421, 47512, 48297, 50064, 50902, 52703, 52764, 54674, 55307, 56663, 58425, 59028, 60576, 60995, 62205, 63129, 64488, 66999, 67189, 68512, 68984, 70170, 71365, 75618, 76793, 77571, 79047, 80309, 83179, 84345, 87016, 87874, 88566, 89607, 91718, 92887, 93839, 95103, 97974, 99583, 101337, 102040, 103626, 104554, 106947, 107205, 108622, 111837, 112800, 113949, 114642, 116291, 117177, 121238, 125492, 126637, 129170, 130986, 131697, 134414, 134699, 136635, 139964, 143294, 144874, 146605, 147499, 148593, 150146, 152318, 152834, 156836, 157150, 160782, 163010, 163502, 164868, 170984, 172922, 174171, 177853, 180249, 182071, 185403, 188314, 190726, 190894, 193477, 196832, 199646, 201472, 202699, 205325, 206811, 208748, 214435, 217182, 218011, 225350, 226682, 229163, 231694, 233570, 234619, 235152, 238727, 240814, 247822, 253857, 254305, 260433, 261620, 262317, 266550, 269195, 271511, 274250, 274753, 280180, 284289, 290005, 293034, 295037, 296506, 298414, 302663, 305782, 308841, 317739, 321173, 323672, 324806, 329181, 331018, 336642, 340901, 343359, 347001, 348110, 348899, 362520, 366119, 368235, 370696, 371542, 377450, 380366, 382012, 382245, 384957, 387479, 390518, 391462, 399174, 403920, 411847, 412671, 416880, 417991, 422453, 433973, 434773, 440619, 441148, 443779, 446065, 456289, 458426, 462402, 470670, 474668, 475800, 481476, 482868, 498435, 501084, 508193, 511258, 514644, 524307, 527197, 535369, 536903, 538331, 542020, 555275, 564016, 566106, 567408, 572027, 582478, 583407, 585871, 593257, 596837, 598426, 599784, 607794, 610404, 621790, 624574, 627703, 633442, 640047, 648858, 659179, 663558, 667337, 672815, 673522, 686013, 691686, 693169, 694279, 696931, 703162, 711364, 723249, 729860, 731008, 739958, 740124, 744403, 753293, 768134, 770113, 773912, 779917, 787407, 794900, 797567, 800658, 813959, 814414, 827123, 829129, 839728, 847430, 850695, 851627, 862856, 880796, 884725, 889285, 896691, 897160, 904970, 909586, 915254, 922852, 935695, 937825, 938876, 959937, 961353, 964857, 970227, 976356, 980581, 986799, 1008106, 1009835, 1016906, 1020306, 1028612, 1033242, 1036012, 1042818, 1050881, 1051783, 1060844, 1086402, 1092043, 1096162, 1103456, 1123464, 1134057, 1136410, 1144080, 1145152, 1147774, 1156687, 1164278, 1166255, 1174751, 1187057, 1195316, 1201262, 1207345, 1212654, 1218610, 1225019, 1227887, 1240777, 1247071, 1258235, 1265462, 1274089, 1279515, 1288613, 1298980, 1306248, 1326918, 1333809, 1341190, 1343482, 1367480, 1372734, 1374779, 1384952, 1388147, 1394240, 1395346, 1409612, 1417336, 1418943, 1423296, 1446209, 1448494, 1462599, 1468933, 1474698, 1496110, 1502217, 1508335, 1513944, 1549693, 1552361, 1558304, 1567726, 1578307, 1593543, 1594370, 1596552, 1604567, 1611655, 1638201, 1657904, 1661549, 1668344, 1684653, 1700848, 1704061, 1712218, 1733148, 1744400, 1756959, 1766186, 1770297, 1774640, 1783782, 1790804, 1797186, 1819167, 1822095, 1835790, 1838687, 1840248, 1843265, 1858487, 1871701, 1874449, 1907155, 1933219, 1941873, 1953108, 1960964, 1970086, 1995385, 2005526, 2006388, 2012407, 2022419, 2027444, 2032071, 2046348, 2049691, 2081218, 2085045, 2107005, 2111011, 2117147, 2128804, 2130734, 2133565, 2163069, 2165643, 2183398, 2186582, 2200866, 2228833, 2238757, 2260397, 2287997, 2303690, 2306210, 2311079, 2319657, 2347177, 2348345, 2364629, 2380657, 2386691, 2392303, 2413369, 2429645, 2435861, 2445907, 2454603, 2461156, 2481207, 2493269, 2496558, 2526270, 2549274, 2559084, 2565601, 2571993, 2574622, 2589585, 2602736, 2606052, 2635578, 2636056, 2649712, 2667175, 2697913, 2705598, 2716472, 2726625, 2740640, 2748032, 2769317, 2773637, 2777175, 2796454, 2808141, 2818050, 2822209, 2828335, 2853048, 2858954, 2879003, 2898699, 2906226, 2928135, 2935468, 2950167, 2955230, 2959204, 2981209, 2999992, 3013106, 3016185, 3016728, 3033485, 3041287, 3046405, 3085842, 3097363, 3129048, 3137101, 3148974, 3153026, 3165425, 3172200, 3187649, 3208795, 3228028, 3239797, 3265353, 3281537, 3310390, 3330139, 3349916, 3351744, 3360950, 3366598, 3375910, 3382995, 3411775, 3438201, 3447140, 3453811, 3471520, 3485127, 3522748, 3569412, 3575690, 3578298, 3585562, 3593337, 3624737, 3626198, 3651501, 3667524, 3674434, 3675907, 3738616, 3754186, 3765841, 3786330, 3807381, 3818043, 3829535, 3831874, 3838373, 3862508, 3910613, 3942689, 3950184, 3954465, 3978469, 3992767, 4014701, 4032219, 4033924, 4065368, 4078004, 4089606, 4101646, 4119004, 4155098, 4166329, 4176904, 4182945, 4197748, 4211593, 4218728, 4253237, 4275441, 4288635, 4298689, 4301972, 4329866, 4357640, 4392330, 4403327, 4415543, 4434657, 4454780, 4460817, 4467239, 4489541, 4518764, 4526891, 4541320, 4560957, 4568090, 4582032, 4609341, 4631837, 4683082, 4688874, 4714962, 4728230, 4733954, 4744119, 4797763, 4819301, 4823437, 4850997, 4865482, 4886981, 4907820, 4931122, 4957782, 5005971, 5014678, 5031077, 5054902, 5059300, 5088659, 5119815, 5135680, 5153376, 5210102, 5213548, 5253584]
for _ in range(int(input())):
n=int(input())
sum=0
for i in range(n):
print(lst[i],end=" ")
sum+=lst[i]
print()
print(sum)
``` | {
"language": "python",
"test_cases": [
{
"input": "4\n1\n2\n3\n4\n",
"output": "1\n1\n1 2\n3\n1 2 4\n7\n1 2 4 8\n15\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/PROC2020/problems/CHFBANK"
} | vfc_3630 |
apps | verifiable_code | 1198 | Solve the following coding problem using the programming language python:
Chef recently took a course in linear algebra and learned about linear combinations of vectors. Therefore, in order to test his intelligence, Raj gave him a "fuzzy" problem to solve.
A sequence of integers $B_1, B_2, \ldots, B_M$ generates an integer $K$ if it is possible to find a sequence of integers $C_1, C_2, \ldots, C_M$ such that $C_1 \cdot B_1 + C_2 \cdot B_2 + \ldots + C_M \cdot B_M = K$.
In this problem, Chef has a sequence $A_1, A_2, \ldots, A_N$ and he should answer $Q$ queries. In each query, he is given an integer $K$; the answer to this query is the number of pairs $(l, r)$ such that $1 \le l \le r \le N$ and the subsequence $(A_l, A_{l+1}, \ldots, A_r)$ generates $K$.
Chef has no idea how to solve this problem ― can you help him find the answers to all queries?
-----Input-----
- The first line of the input contains a single integer $N$.
- The second line contains $N$ space-separated integers $A_1, A_2, \ldots, A_N$.
- The third line contains a single integer $Q$.
- The following $Q$ lines describe queries. Each of these lines contains a single integer $K$.
-----Output-----
For each query, print a single line containing one integer ― the number of contiguous subsequences that generate $K$.
-----Constraints-----
- $1 \le N, Q \le 10^5$
- $1 \le A_i \le 10^9$ for each valid $i$
- $1 \le K \le 10^6$
-----Subtasks-----
Subtask #1 (10 points): $1 \le N \le 1,000$
Subtask #2 (90 points): original constraints
-----Example Input-----
2
2 4
3
1
2
8
-----Example Output-----
0
2
3
-----Explanation-----
The sequence $(2, 4)$ has three contiguous subsequences: $(2)$, $(4)$ and $(2, 4)$.
- In the first query, $1$ cannot be generated by any subsequence.
- In the second query, $2$ is generated by subsequences $(2)$ and $(2, 4)$. For example, for the subsequence $(2, 4)$, we can choose $C_1 = 1$ and $C_2 = 0$.
- In the third query, $8$ is generated by all three subsequences.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
import math
import bisect
from functools import reduce
from collections import defaultdict
# import sys
# input = sys.stdin.readline
def inn():
return int(input())
def inl():
return list(map(int, input().split()))
MOD = 10**9+7
INF = inf = 10**18+5
n = inn()
a = inl()
k = []
for q in range(inn()):
k.append(inn())
gcdn = reduce(math.gcd, a)
lim = max(k)+1
ans = defaultdict(int)
ans[1] = 0
for i in range(n):
cur_gcd = a[i]
for j in range(i, n):
cur_gcd = math.gcd(cur_gcd, a[j])
if cur_gcd==1 or cur_gcd//gcdn==1:
ans[cur_gcd] += (n-j)
break
ans[cur_gcd] += 1
# print(ans)
keys = list(ans.keys())
ans1 = [0]*lim
for i in keys:
for j in range(i, lim, i):
ans1[j] += ans[i]
# print(ans1[:10])
for i in k:
print(ans1[i])
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n2 4\n3\n1\n2\n8\n",
"output": "0\n2\n3\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/FUZZYLIN"
} | vfc_3634 |
apps | verifiable_code | 1199 | Solve the following coding problem using the programming language python:
In a country called Chef Land, there was a lot of monetary fraud, so Chefu, the head of the country, decided to choose new denominations of the local currency ― all even-valued coins up to an integer $N$ should exist. After a few days, a citizen complained that there was no way to create an odd value, so Chefu decided that he should also introduce coins with value $1$. Formally, you are given an integer $N$; for $v = 1$ and each even positive integer $v \le N$, coins with value $v$ exist.
You are also given an integer $S$. To handle transactions quickly, find the minimum number of coins needed to pay a price $S$.
-----Input-----
- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
- The first and only line of each test case contains two space-separated integers $S$ and $N$.
-----Output-----
For each test case, print a single line containing one integer ― the minimum number of coins.
-----Constraints-----
- $1 \le T \le 10,000$
- $1 \le S \le 10^9$
- $2 \le N \le 10^9$
- $N$ is even
-----Subtasks-----
Subtask #1 (100 points): original constraints
-----Example Input-----
4
2 2
1 14
30 10
31 4
-----Example Output-----
1
1
3
9
-----Explanation-----
Example case 1: One coin with value $2$ is sufficient.
Example case 2: We need to use one coin with value $1$.
Example case 3: We need $3$ coins, each with value $10$.
Example case 4: We can use seven coins with value $4$, one coin with value $2$ and one coin with value $1$.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
for i in range(int(input())):
n,k=list(map(int,input().split()))
t=0
if n%2!=0:
n-=1
t+=1
t+=(n//k)
if n%k!=0:
t+=1
print(t)
``` | {
"language": "python",
"test_cases": [
{
"input": "4\n2 2\n1 14\n30 10\n31 4\n",
"output": "1\n1\n3\n9\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/CHFMOT18"
} | vfc_3638 |
apps | verifiable_code | 1200 | Solve the following coding problem using the programming language python:
Two sisters, A and B, play the piano every day. During the day, they can play in any order. That is, A might play first and then B, or it could be B first and then A. But each one of them plays the piano exactly once per day. They maintain a common log, in which they write their name whenever they play.
You are given the entries of the log, but you're not sure if it has been tampered with or not. Your task is to figure out whether these entries could be valid or not.
-----Input-----
- The first line of the input contains an integer $T$ denoting the number of test cases. The description of the test cases follows.
- The first line of each test case contains a string $s$ denoting the entries of the log.
-----Output-----
- For each test case, output yes or no according to the answer to the problem.
-----Constraints-----
- $1 \le T \le 500$
- $2 \le |s| \le 100$
- $|s|$ is even
- Each character of $s$ is either 'A' or 'B'
-----Example Input-----
4
AB
ABBA
ABAABB
AA
-----Example Output-----
yes
yes
no
no
-----Explanation-----
Testcase 1: There is only one day, and both A and B have played exactly once. So this is a valid log. Hence 'yes'.
Testcase 2: On the first day, A has played before B, and on the second day, B has played first. Hence, this is also a valid log.
Testcase 3: On the first day, A played before B, but on the second day, A seems to have played twice. This cannot happen, and hence this is 'no'.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
def checkValidity(s):
count = 0
previous = ""
for x in s:
if count == 0:
previous = x
count += 1
elif count == 1:
count = 0
if previous == x:
return "no"
return "yes"
t = int(input())
for _ in range(t):
s = input()
print(checkValidity(s))
``` | {
"language": "python",
"test_cases": [
{
"input": "4\nAB\nABBA\nABAABB\nAA\n",
"output": "yes\nyes\nno\nno\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/PLAYPIAN"
} | vfc_3642 |
apps | verifiable_code | 1201 | Solve the following coding problem using the programming language python:
Kim has broken in to the base, but after walking in circles, perplexed by the unintelligible base design of the JSA, he has found himself in a large, empty, and pure white, room.
The room is a grid with H∗W$H*W$ cells, divided into H$H$ rows and W$W$ columns. The cell (i,j)$(i,j)$ is at height A[i][j]$A[i][j]$. Unfortunately, his advanced sense of smell has allowed him to sense a mercury leak, probably brought in by Jishnu to end his meddling. The mercury leak has a power (which determines what height the mercury can reach before dissipating into harmless quantities) and a source cell. It spreads from cells it has already reached to other cells in the four cardinal directions: north, south, east, and west. (That is, the mercury can spread up, down, right, or left in the grid, but not diagonally.) Mercury can only spread to a cell if the cell's height is strictly less than the power value.
Unfortunately, Kim does not exactly know the starting cell or the power value of the mercury leak. However, his impressive brain has determined that it must be one of Q$Q$ (power, starting cell) combinations. For each combination, he wants to find out how many cells are dangerous for him to go to: that is, how many cells will eventually be reached by the mercury. This will help him determine a suitable cell to stay in and slowly fix the leak from above.
Can you help Kim achieve this objective?
Note: If the starting cell's height is not less than the power level, the mercury immediately dissipates. So, in this case, output 0.
-----Input:-----
- First line will contain T$T$, number of testcases. Then the testcases follow.
- The first line in each testcase contains three integers, H$H$, W$W$, and Q$Q$.
- On the 2$2$nd to (H+1)$(H+1)$th lines of each testcase: The (i+1)$(i+1)$th line contains W$W$ space-separated integers, representing the heights of the cells on the i$i$th row of the grid.
- On the (H+2)$(H+2)$th to (H+Q+1)$(H+Q+1)$th lines of each testcase: The (i+H+1)$(i+H+1)$th line contains 3 space-separated integers, r[i]$r[i]$, c[i]$c[i]$, and p[i]$p[i]$, which represents a (power, starting cell) combination. For this specific combination, the mercury leak originates on the cell (r[i],c[i])$(r[i],c[i])$ and has power p[i]$p[i]$.
-----Output:-----
For each testcase, output Q$Q$ lines, with each line containing one integer. The i$i$th line should output the number of dangerous cells, given that the leak originated on cell (r[i],c[i])$(r[i],c[i])$ with power p[i]$p[i]$, as defined in the input. Read the sample and sample explanation for more details.
-----Constraints-----
- 1≤T≤2$1 \leq T \leq 2$
- 1≤H≤1000$1 \leq H \leq 1000$
- 1≤W≤1000$1 \leq W \leq 1000$
- 1≤Q≤2∗105$1 \leq Q \leq 2*10^5$
- 1≤r[i]≤H$1 \leq r[i] \leq H$ for all i$i$
- 1≤c[i]≤W$1 \leq c[i] \leq W$ for all i$i$
- 0≤A[i][j]≤109$0 \leq A[i][j] \leq 10^9$ for all (i,j)$(i,j)$
- 0≤p[i]≤109$0 \leq p[i] \leq 10^9$ for all i$i$.
-----Subtasks-----
- 10 points : A[i][j]=$A[i][j] =$ constant k$k$ for all (i,j)$(i,j)$ (the heights of all cells are equal).
- 20 points : H=1$H=1$, Q≤1000$Q \leq 1000$.
- 30 points: r[i]=$r[i] =$ constant x$x$, c[i]=$c[i] =$ constant y$y$ for all i$i$ (the starting cell is fixed).
- 40 points: No additional constraints.
-----Sample Input:-----
1
5 5 3
4 3 9 7 2
8 6 5 2 8
1 7 3 4 3
2 2 4 5 6
9 9 9 9 9
3 4 6
3 2 5
1 4 9
-----Sample Output:-----
10
0
19
-----EXPLANATION:-----
For the first query, the cell (3,4)$(3,4)$ has height 4. The mercury can reach the following cells: (2,3)$(2,3)$, (2,4)$(2,4)$, (3,1)$(3,1)$, (3,3)$(3,3)$, (3,4)$(3,4)$, (3,5)$(3,5)$, (4,1)$(4,1)$, (4,2)$(4,2)$, (4,3)$(4,3)$, (4,4)$(4,4)$, for a total of 10. Note that it cannot reach cell (4,5)$(4,5)$ because the height (6) is equal to the power value (6).
For the second query, the cell (3,2)$(3,2)$ has height 7. Since the power value of 5 is less than or equal to the height of 7, the mercury immediately dissipates and so it reaches 0 cells.
For the third query, the mercury can reach all cells except the bottom row and the cell (1,3)$(1,3)$.
Note that (x,y)$(x,y)$ means the cell on the x$x$-th row and y$y$-th column.
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 solve(l,r,c,row,col,po):
count=0
visited=set()
stack=set()
stack.add((l[row][col],row,col))
while stack:
ele=stack.pop()
visited.add((ele[1],ele[2]))
if ele[0]<po:
count+=1
if ele[1]-1>=0 and (ele[1]-1,ele[2]) not in visited:
if l[ele[1]-1][ele[2]]<po:
stack.add((l[ele[1]-1][ele[2]],ele[1]-1,ele[2]))
if ele[1]+1<r and (ele[1]+1,ele[2]) not in visited:
if l[ele[1]+1][ele[2]]<po:
stack.add((l[ele[1]+1][ele[2]],ele[1]+1,ele[2]))
if ele[2]-1>=0 and (ele[1],ele[2]-1) not in visited:
if l[ele[1]][ele[2]-1]<po:
stack.add((l[ele[1]][ele[2]-1],ele[1],ele[2]-1))
if ele[2]+1<c and (ele[1],ele[2]+1) not in visited:
if l[ele[1]][ele[2]+1]<po:
stack.add((l[ele[1]][ele[2]+1],ele[1],ele[2]+1))
return count
for _ in range(int(input())):
r,c,q=map(int,input().split())
l=[]
for i in range(r):
a=list(map(int,input().split()))
l.append(a)
for i in range(q):
row,col,po=map(int,input().split())
print(solve(l,r,c,row-1,col-1,po))
``` | {
"language": "python",
"test_cases": [
{
"input": "1\n5 5 3\n4 3 9 7 2\n8 6 5 2 8\n1 7 3 4 3\n2 2 4 5 6\n9 9 9 9 9\n3 4 6\n3 2 5\n1 4 9\n",
"output": "10\n0\n19\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/UWCOI20C"
} | vfc_3646 |
apps | verifiable_code | 1202 | Solve the following coding problem using the programming language python:
Mark loves eating chocolates and also likes to be fit. Given the calorie count for every chocolate he eats, find what he has to do to burn the calories.
The name of the chocolates along with its calorie count are given as follows:
Calories per one whole bar:
Dairy milk (D)
238
Twix (T)
244
Milky Bar (M)
138
Bounty (B)
279
Crunchie (C)
186
The exercises preferred by him and the calories burnt are as follows:
Calories burnt per km:
Running
50
Cycling
5
Walking
0.5
Find the number of kilometers he has to run, cycle or walk to burn all of the calories.
Priority given to the exercises is as follows:
Running > Cycling > Walking
-----Input:-----
- It is a one line string consisting of the names(initial letter) of all the chocolates he has eaten.
-----Output:-----
Print three lines. First line representing how much he ran(in km), second line representing how much he cycled(in km), third line representing how much he walked(in km).
-----Constraints-----
- 1 <= length of input string <= 10.
-----Sample Input:-----
DDTM
-----Sample Output:-----
17
1
6
-----EXPLANATION:-----
Calorie intake = 238 + 238 + 244 + 138 = 858
( 17km x 50 ) + ( 1km x 5 ) + ( 6km x 0.5 ) = 858.
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 = { 'D': 238, 'T': 244, 'M': 138, 'B': 279, 'C': 186 }
s = list(input())
totalCal = 0
for i in range(len(s)):
if s[i] == 'D':
totalCal += d['D']
if s[i] == 'T':
totalCal += d['T']
if s[i] == 'M':
totalCal += d['M']
if s[i] == 'B':
totalCal += d['B']
if s[i] == 'C':
totalCal += d['C']
R = totalCal // 50
Rm = totalCal % 50
C = Rm // 5
Cm = Rm % 5
x = totalCal - (R * 50 + C * 5)
# print(totalCal - R * 50 + C * 5)
W = int(x * 4 * 0.5)
# print(R * 50 + C * 5 + W * 0.5)
print(R)
print(C)
print(W)
``` | {
"language": "python",
"test_cases": [
{
"input": "DDTM\n",
"output": "17\n1\n6\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/RTCG2020/problems/RTCG002"
} | vfc_3650 |
apps | verifiable_code | 1203 | Solve the following coding problem using the programming language python:
Given a set of N natural numbers 1,2,3........N and Q query.For each query you have to calculate the total number of subset in which Ith.
number of set come at Kth postion.Elements of every subset should be in sorted order.
The answer could be very large so you have to print answer modulo 1e9+7.
-----Input:-----
- The first line of input cotains a single integer T denoting the number of test cases.
- For every test case it contains two number N and Q.
- Next Q line contains two number I and K.
-----Output:-----
For each test case print required answer.
-----Constraints and Subtasks:-----
- 1<=T<=5
- 1<=N, K<=4000
- 1<=Q<=1000000
Subtask 3: 5 points
- 1<=T<=5
- 1<=N, K<=16
- 1<=Q<=1000
Subtask 1: 25 points
- T=1
- 1<=N, K<=4000
- 1<=Q<=100000
Subtask 2: 70 points
- Original Constraints.
-----Example:-----
Input:
1
3 3
1 2
2 1
3 2
Output:
0
2
2
-----Explanation:-----
For N=3
total subsets are:
{1}
{2}
{3}
{1,2}
{1,3}
{2,3}
{1,2,3}
Now we can see that for I=1 and K=2 there is no subset in which 1 come at 2nd position so the answer is Zero for that query.
For 2nd query I=2 and K=1 there are two subset i.e {2,3} and {2} in which 2 come at 1st position.
Same for 3rd querry there is two subset i.e{1,3} and {2,3}.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
import math
f = math.factorial
for u in range(eval(input())):
n, q = list(map(int, input().split()))
for j in range(q):
i,k = list(map(int, input().split()))
if k>i:
c=0
print(c)
else:
a=2**(n-i)
b=1
d=int(i-1)
e=1
h=1
g=1
#b=f(i-1)/f(k-1)/f(i-k)
if(k-1>i-k):
for z in range(i-k):
b=b*d
d=d-1
e=e*h
h=h+1
b=b/e
else:
for z in range(k-1):
b=b*d
d=d-1
e=e*g
g=g+1
b=b/e
c=a*b
c=c%1000000007
print(c)
``` | {
"language": "python",
"test_cases": [
{
"input": "1\n3 3\n1 2\n2 1\n3 2\n",
"output": "0\n2\n2\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/CDVA16/problems/CDVA1607"
} | vfc_3654 |
apps | verifiable_code | 1204 | Solve the following coding problem using the programming language python:
You are given two strings $S$ and $R$. Each of these strings has length $N$. We want to make $S$ equal to $R$ by performing the following operation some number of times (possibly zero):
- Choose two integers $a$ and $b$ such that $1 \le a \le b \le N$.
- For each $i$ such that $a \le i \le b$, replace the $i$-th character of $S$ by the $i$-th character of $R$.
Suppose that we make $S$ equal to $R$ by performing this operation $k$ times, in such a way that the total number of replaced characters (i.e. the sum of all $k$ values of $b-a+1$) is $l$. Then, the cost of this process is defined as $k \cdot l$.
Find the minimum cost with which we can make $S$ equal to $R$.
-----Input-----
- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
- The first line of each test case contains a single string $S$.
- The second line contains a single string $R$.
-----Output-----
For each test case, print a single line containing one integer ― the minimum cost.
-----Constraints-----
- $1 \le T \le 4,000$
- $1 \le N \le 10^6$
- $|S| = |R| = N$
- $S$ and $R$ contain only lowercase English letters
- the sum of $N$ over all test cases does not exceed $2 \cdot 10^6$
-----Example Input-----
1
adefb
bdefa
-----Example Output-----
4
-----Explanation-----
Example case 1: $S$ can be made equal to $R$ in two moves. First, we replace $S_1$ by $R_1$ and then replace $S_5$ by $R_5$. We have $k = l = 2$, so the cost is $2 \cdot 2 = 4$. If we wanted to perform only one operation, the cost would be $5$.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
for t in range(int(input())):
s = input()
r = input()
diff = list()
index = list()
cnt = 0
for i in range(len(s)):
if s[i] != r[i]:
cnt += 1
index.append(i)
for i in range(1, len(index)):
diff.append(index[i] - index[i - 1] - 1)
diff.sort()
fmin = cnt ** 2
oper = cnt ; moves = cnt
for i in diff:
moves += i
oper -= 1
fmin = min(fmin, moves * oper)
print(fmin)
``` | {
"language": "python",
"test_cases": [
{
"input": "1\nadefb\nbdefa\n",
"output": "4\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/MINOPS"
} | vfc_3658 |
apps | verifiable_code | 1205 | Solve the following coding problem using the programming language python:
Do you know Professor Saeed? He is the algorithms professor at Damascus University. Yesterday, he gave his students hard homework (he is known for being so evil) - for a given binary string $S$, they should compute the sum of $F(S, L, R)$ over all pairs of integers $(L, R)$ ($1 \le L \le R \le |S|$), where the function $F(S, L, R)$ is defined as follows:
- Create a string $U$: first, set $U = S$, and for each $i$ ($L \le i \le R$), flip the $i$-th character of $U$ (change '1' to '0' or '0' to '1').
- Then, $F(S, L, R)$ is the number of valid pairs $(i, i + 1)$ such that $U_i = U_{i+1}$.
As usual, Professor Saeed will give more points to efficient solutions. Please help the students solve this homework.
-----Input-----
- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
- The first and only line of each test case contains a single string $S$.
-----Output-----
For each test case, print a single line containing one integer $\sum_{1 \le L \le R \le |S|} F(S, L, R)$.
-----Constraints-----
- $1 \le T \le 100$
- $1 \le |S| \le 3 \cdot 10^6$
- the sum of $|S|$ over all test cases does not exceed $6 \cdot 10^6$
-----Subtasks-----
Subtask #1 (50 points):
- $1 \le |S| \le 300$
- the sum of $|S|$ over all test cases does not exceed $600$
Subtask #2 (50 points): original constraints
-----Example Input-----
1
001
-----Example Output-----
6
-----Explanation-----
Example case 1:
- $L = 1, R = 1$: $U$ is "101", $F = 0$
- $L = 2, R = 2$: $U$ is "011", $F = 1$
- $L = 3, R = 3$: $U$ is "000", $F = 2$
- $L = 1, R = 2$: $U$ is "111", $F = 2$
- $L = 2, R = 3$: $U$ is "010", $F = 0$
- $L = 1, R = 3$: $U$ is "110", $F = 1$
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
for _ in range(int(input())):
s=input()
n=len(s)
t=0
ans=0
for i in range(n-1):
if(s[i]==s[i+1]):
t=t+1
x=t
for i in range(n):
t=x
if(i!=0):
if(s[i]==s[i-1]):
t=t-1
else:
t=t+1
y=t
for j in range(i,n):
t=y
try:
if(s[j]==s[j+1]):
t=t-1
else:
t=t+1
except:
pass
ans=ans+t
print(ans)
``` | {
"language": "python",
"test_cases": [
{
"input": "1\n001\n",
"output": "6\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/EVIPRO"
} | vfc_3662 |
apps | verifiable_code | 1206 | Solve the following coding problem using the programming language python:
As you might remember, the collector of Siruseri had ordered
a complete revision of the Voters List. He knew that constructing
the list of voters is a difficult task, prone to errors. Some
voters may have been away on vacation, others may have moved
during the enrollment and so on.
To be as accurate as possible, he entrusted the task to three different
officials. Each of them was to independently record the list of voters and
send it to the collector. In Siruseri, every one has a ID number and
the list would only list the ID numbers of the voters and not their names.
The officials were expected to arrange the ID numbers in ascending order
in their lists.
On receiving the lists, the Collector realised that there were
discrepancies - the three lists were not identical. He decided
to go with the majority. That is, he decided to construct the
final list including only those ID numbers that appeared in at
least 2 out of the 3 lists. For example if the three lists
were
23 30 42 57 90
21 23 35 57 90 92
21 23 30 57 90
then the final list compiled by the collector would be:
21 23 30 57 90
The ID numbers 35, 42 and 92 which appeared in only one list
each do not figure in the final list.
Your task is to help the collector by writing a program that
produces the final list from the three given lists.
Input format
The first line of the input contains 3 integers
N1, N2 and
N3. N1 is the number of
voters in the first list, N2 is the number of
voters in the second list and N3 is the number of
voters in the third list. The next N1 lines
(lines 2,...,N1+1) contain one positive integer
each and describe the first list in ascending order. The following
N2 lines (lines
N1+2,...,N1+N2+1)
describe the second list in ascending order and the final
N3 lines (lines
N1+N2+2,...,N1+N2+N3+1)
describe the third list in ascending order.
Output format
The first line of the output should contain a single integer
M indicating the number voters in the final list. The next
M lines (lines 2,...,M+1) should contain one
positive integer each, describing the list of voters in the final
list, in ascending order.
Test data
You may assume that 1 ≤
N1,N2,N3
≤ 50000. You may also assume that in 50% of the inputs 1 ≤ N1,N2,N3 ≤ 2000.
Example
Sample input:
5 6 5
23
30
42
57
90
21
23
35
57
90
92
21
23
30
57
90
Sample output:
5
21
23
30
57
90
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
from sys import stdout, stdin
n,m,o = list(map(int, stdin.readline().split()))
n= n+m+o
l=[]
a=[]
for i in range(n):
b= int(stdin.readline())
if(b in l and b not in a):
l.append(b)
a.append(b)
elif(b not in l):
l.append(b)
a.sort()
stdout.write(str(len(a)) + '\n')
stdout.write(''.join([str(id) + '\n' for id in a]))
``` | {
"language": "python",
"test_cases": [
{
"input": "5 6 5\n23\n30\n42\n57\n90\n21\n23\n35\n57\n90\n92\n21\n23\n30\n57\n90\nSample output:\n5\n21\n23\n30\n57\n90\n",
"output": "",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/IARCSJUD/problems/VOTERSDI"
} | vfc_3666 |
apps | verifiable_code | 1207 | Solve the following coding problem using the programming language python:
Chef is the new king of the country Chefland. As first and most important responsibility he wants to reconstruct the road system of Chefland. There are N (1 to N) cities in the country and each city i has a population Pi. Chef wants to build some bi-directional roads connecting different cities such that each city is connected to every other city (by a direct road or through some other intermediate city) and starting from any city one can visit every other city in the country through these roads. Cost of building a road between two cities u and v is Pu x Pv. Cost to build the road system is the sum of cost of every individual road that would be built.
Help king Chef to find the minimum cost to build the new road system in Chefland such that every city is connected to each other.
-----Input-----
The first line of the input contains an integer T denoting the number of test cases. The description of T test cases follows.
First line contains an integer N denoting the number of cities in the country. Second line contains N space separated integers Pi, the population of i-th city.
-----Output-----
For each test case, print a single integer, the minimum cost to build the new road system on separate line.
-----Constraints-----
- 1 ≤ T ≤ 10
- 1 ≤ N ≤ 105
- 1 ≤ Pi ≤ 106
-----Example-----
Input:
2
2
5 10
4
15 10 7 13
Output:
50
266
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
t=int(input())
for _ in range(t):
n=int(input())
a=list(map(int,input().split()))
a.sort()
s=sum(a)
if a[0]*(s-a[0])<=a[n-1]*(s-a[n-1]):
print(a[0]*(s-a[0]))
else:
print(a[n-1]*(s-a[n-1]))
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n2\n5 10\n4\n15 10 7 13\n",
"output": "50\n266\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/KINGSHIP"
} | vfc_3670 |
apps | verifiable_code | 1208 | Solve the following coding problem using the programming language python:
Chef is solving mathematics problems. He is preparing for Engineering Entrance exam. He's stuck in a problem.
$f(n)=1^n*2^{n-1}*3^{n-2} * \ldots * n^{1} $
Help Chef to find the value of $f(n)$.Since this number could be very large, compute it modulo $1000000007$.
-----Input:-----
- First line will contain $T$, number of testcases. Then the testcases follow.
- Each testcase contains of a single line of input, $N$.
-----Output:-----
For each testcase, output in a single line the value of $f(n)$ mod $1000000007$.
-----Constraints-----
- $1 \leq T \leq 10^6$
- $1 \leq N \leq 10^6$
-----Subtasks-----
Subtask 1(24 points) :
- $1 \leq T \leq 5000$
- $1 \leq N \leq 5000$
Subtask 2(51 points) : original constraints
-----Sample Input:-----
1
3
-----Sample Output:-----
12
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())
t=[]
for _ in range(T):
N=int(input())
t.append(N)
N=max(t)+1
l=[0 for i in range(N)]
p=1
a=1
for i in range(1,N):
a=(a*i)%1000000007
p=p*a%1000000007
l[i]=p
for i in t:
print(l[i])
``` | {
"language": "python",
"test_cases": [
{
"input": "1\n3\n",
"output": "12\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/MATHL"
} | vfc_3674 |
apps | verifiable_code | 1209 | Solve the following coding problem using the programming language python:
It's winter and taking a bath is a delicate matter. Chef has two buckets of water. The first bucket has $v_1$ volume of cold water at temperature $t_1$. The second has $v_2$ volume of hot water at temperature $t_2$. Chef wants to take a bath with at least $v_3$ volume of water which is at exactly $t_3$ temperature. To get the required amount of water, Chef can mix some water obtained from the first and second buckets.
Mixing $v_x$ volume of water at temperature $t_x$ with $v_y$ volume of water at temperature $t_y$ yields $v_x + v_y$ volume of water at temperature calculated as
vxtx+vytyvx+vyvxtx+vytyvx+vy\frac{v_x t_x + v_y t_y}{v_x + v_y}
Help Chef figure out if it is possible for him to take a bath with at least $v_3$ volume of water at temperature $t_3$.
Assume that Chef has no other source of water and that no heat is lost by the water in the buckets with time, so Chef cannot simply wait for the water to cool.
-----Input-----
- The first line contains $n$, the number of test cases. $n$ cases follow.
- Each testcase contains of a single line containing 6 integers $v_1, t_1, v_2, t_2, v_3, t_3$.
-----Output-----
- For each test case, print a single line containing "YES" if Chef can take a bath the way he wants and "NO" otherwise.
-----Constraints-----
- $1 \leq n \leq 10^5$
- $1 \leq v_1, v_2, v_3 \leq 10^6$
- $1 \leq t_1 < t_2 \leq 10^6$
- $1 \leq t_3 \leq 10^6$
-----Sample Input-----
3
5 10 5 20 8 15
5 10 5 20 1 30
5 10 5 20 5 20
-----Sample Output-----
YES
NO
YES
-----Explanation-----
- Case 1: Mixing all the water in both buckets yields 10 volume of water at temperature 15, which is more than the required 8.
- Case 2: It is not possible to get water at 30 temperature.
- Case 3: Chef can take a bath using only the water in the second bucket.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
# cook your dish here
try:
for i in range(int(input())):
v1,t1,v2,t2,v3,t3=map(int,input().split())
ok = 0
if t1 <= t3 <= t2:
x, y = t2 - t3, t3 - t1
ok = x * v3 <= (x + y) * v1 and y * v3 <= (x + y) * v2
print('YES' if ok else 'NO')
except:
pass
``` | {
"language": "python",
"test_cases": [
{
"input": "3\n5 10 5 20 8 15\n5 10 5 20 1 30\n5 10 5 20 5 20\n",
"output": "YES\nNO\nYES\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/CLBATH"
} | vfc_3678 |
apps | verifiable_code | 1210 | Solve the following coding problem using the programming language python:
-----Problem Statement-----
One of the things JEC is known for is its GR (Group Recreation) where juniors and seniors do friendly interaction ;P
As for the new session of 2020 seniors decided to have their first GR and give them some treat. Juniors were excited about it they came to college canteen aligned in a line and counted themselves one by one from left to right so that every junior gets his/her treat. But seniors played a game and they will treat only the ones who passes in this game. Game is simple all they need to do is to alternate their language (between Hindi and English) while telling their positions that is if the junior just before you told 2 in English you need to say 3 in Hindi . You do not want to be the one left without a treat.
You are the junior standing at position $X$ from left and the counting could start from left or right you have to predict which number you have to speak and in which language when your turn comes.
-----Input:-----
-
First line will contain $T$, number of testcases. Then the testcases follow.
-
Each testcase contains 2 lines first consist 2 space separated integers, $N$ (total count) , $X$ (your position from left), next line consist of 2 space separated characters L or R (Direction from which counting starts L-left, R-Right) and H or E (the language to start counting).
-----Output:-----
For each testcase, output a single line consisting space seperated Integer P and Character L
where P is the number you will speak and L is the language (H or E).
-----Constraints-----
- $1 \leq T \leq 1000$
- $1 \leq N \leq 120$
- $1 \leq X \leq N$
-----Sample Input:-----
2
15 5
L H
20 14
R E
*try to trim extra white spaces like new line during input in case of wrong answer
-----Sample Output:-----
5 H
7 E
-----EXPLANATION:-----
- When counting starts from left with H it alternates like H E H E H….. on the fifth position H comes
- When Count starts from right with E it alternates like E H E H E H E….. with E on the position of 14th student from right.
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:
t=t-1
n,x=input().split()
n=int(n)
x=int(x)
d,l=input().split()
if d=='L':
p=x
elif d=='R':
p=(n-x)+1
if p%2==1:
if l=='H':
lang='H'
else:
lang='E'
elif p%2==0:
if l=='H':
lang='E'
else:
lang='H'
print(p,lang)
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n15 5\nL H\n20 14\nR E\n*try to trim extra white spaces like new line during input in case of wrong answer\n",
"output": "5 H\n7 E\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/COPT2020/problems/GRDAY1"
} | vfc_3682 |
apps | verifiable_code | 1211 | Solve the following coding problem using the programming language python:
The chef is having one string of English lower case alphabets only. The chef wants to remove all "abc" special pairs where a,b,c are occurring consecutively. After removing the pair, create a new string and again remove "abc" special pair from a newly formed string. Repeate the process until no such pair remains in a string.
-----Input:-----
- First line will contain $T$, number of testcases. Then the testcases follow.
- Each testcase contains of a single line of input, $String$.
-----Output:-----
For each testcase, output in a single line answer, new String with no "abc" special pair.
-----Constraints:-----
$T \leq 2 $
$1 \leq String length \leq 1000 $
-----Sample Input:-----
2
aabcc
bababccc
-----Sample Output:-----
ac
bc
-----EXPLANATION:-----
For 1) after removing "abc" at middle we get a new string as ac.
For 2) string = bababccc
newString1 = babcc // After removing middle "abc"
newString2 = bc //After removing "abc"
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
# cook your dish here
for _ in range(int(input())):
s=input()
while(s.count("abc")!=0):
s=s.replace("abc","")
print(s)
``` | {
"language": "python",
"test_cases": [
{
"input": "2\naabcc\nbababccc\n",
"output": "ac\nbc\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/PBK12020/problems/ITGUY15"
} | vfc_3686 |
apps | verifiable_code | 1213 | Solve the following coding problem using the programming language python:
Chef and his competitor Kefa own two restaurants located at a straight road. The position of Chef's restaurant is $X_1$, the position of Kefa's restaurant is $X_2$.
Chef and Kefa found out at the same time that a bottle with a secret recipe is located on the road between their restaurants. The position of the bottle is $X_3$.
The cooks immediately started to run to the bottle. Chef runs with speed $V_1$, Kefa with speed $V_2$.
Your task is to figure out who reaches the bottle first and gets the secret recipe (of course, it is possible that both cooks reach the bottle at the same time).
-----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 five space-separated integers $X_1$, $X_2$, $X_3$, $V_1$ and $V_2$.
-----Output-----
For each test case, print a single line containing the string "Chef" if Chef reaches the bottle first, "Kefa" if Kefa reaches the bottle first or "Draw" if Chef and Kefa reach the bottle at the same time (without quotes).
-----Constraints-----
- $1 \le T \le 10^5$
- $|X_1|, |X_2|, |X_3| \le 10^5$
- $X_1 < X_3 < X_2$
- $1 \le V_1 \le 10^5$
- $1 \le V_2 \le 10^5$
-----Example Input-----
3
1 3 2 1 2
1 5 2 1 2
1 5 3 2 2
-----Example Output-----
Kefa
Chef
Draw
-----Explanation-----
Example case 1. Chef and Kefa are on the same distance from the bottle, but Kefa has speed $2$, while Chef has speed $1$.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
# cook your dish here
for t in range(int(input())):
x1,x2,x3,v1,v2=[int(x)for x in input().rstrip().split()]
t1=abs(x3-x1)/v1
t2=abs(x3-x2)/v2
if t1<t2:
print("Chef")
elif t1>t2:
print("Kefa")
elif t1==t2:
print("Draw")
else:
pass
``` | {
"language": "python",
"test_cases": [
{
"input": "3\n1 3 2 1 2\n1 5 2 1 2\n1 5 3 2 2\n",
"output": "Kefa\nChef\nDraw\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/CHEFRUN"
} | vfc_3694 |
apps | verifiable_code | 1214 | Solve the following coding problem using the programming language python:
Everybody is worried about Rakesh as the boy does not have much knowledge about the real world. He can not go from one place to another on his own. It's high time he learned to explore the city. He is going to a relative's house situated on the other side of the city on his own. As this is his first time, he is carrying a GPS tracker of a special kind. The tracker continuously sends information to the family of Rakesh about his movement. The information is sent using the following four letters: U, D, R, and L. Those letters indicate the moves taken by Rakesh.
The city can be considered as a grid. Rakesh starts his journey from (0, 0) position of the grid. His relative's house is situated at (Rx, Ry). Rakesh can move in four directions: up, down, right, or left indicated by U, D, R, and L respectively.
Any position of the city with x ordinate negative or greater than M is considered as dangerous. Also, any position of the city with y ordinate negative or greater than N is considered as dangerous. You will be given the total sequence of Rakesh's movement. You need to determine if Rakesh ended up being at his relative's house, at a dangerous place, or at a random place in the city.
To make things clear,
- U indicates a move that increases position along y-axis by 1
- D indicates a move that decreases position along y-axis by 1
- R indicates a move that increases position along x-axis by 1
- L indicates a move that decreases position along x-axis by 1
Note that we are interested in the position of Rakesh at the end of his journey only. He may visit some dangerous place or his relative's house at some intermediate point but that won't affect the answer.
-----Input-----
- The first line of the input contains an integer T denoting the number of test cases. The description of each test case follows.
- The first line of each test case contains two integers M and N.
- The second line contains two integers Rx and Ry.
- The third line contains the length of Rakesh's move sequence.
- The next line contains the move sequence containing letters U, D, R, and L only with no space.
-----Output-----
For each test case, print "Case i: ", and then the answer, where i is the testcase number, 1-indexed. The answer should be any of the following three strings:
- "REACHED" if Rakesh could reach his relative's house
- "DANGER" if Rakesh ended up being in a dangerous place
- "SOMEWHERE" if Rakesh ended up being in somewhere safe place in the city other than his relative's place
Don't print any quotation mark. Check the sample output.
-----Constraints-----
- 1 ≤ T ≤ 10
- 0 ≤ M, N ≤ 10000
- 0 ≤ Rx ≤ M
- 0 ≤ Ry ≤ N
- 0 ≤ Sum of the lengths of all sequences ≤ 10000
-----Example-----
Input:
2
20 20
4 5
13
LLUUUUURRRRRR
10 10
3 4
7
UDUDDRR
Output:
Case 1: REACHED
Case 2: DANGER
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
try:
t=int(input())
for i in range(t):
print("Case {}:".format(i+1), end=" ")
m, n = map(int,input().split())
x, y = map(int,input().split())
l = int(input())
a=input()
destx = a.count("R")-a.count("L")
desty = a.count("U")-a.count("D")
#print(destx, desty)
if (destx<0 or destx>m) or (desty<0 or desty>n):
result = "DANGER"
elif destx == x and desty == y:
result = "REACHED"
else:
result = "SOMEWHERE"
print(result)
except:
pass
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n20 20\n4 5\n13\nLLUUUUURRRRRR\n10 10\n3 4\n7\nUDUDDRR\n",
"output": "Case 1: REACHED\nCase 2: DANGER\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/ZUBREACH"
} | vfc_3698 |
apps | verifiable_code | 1215 | Solve the following coding problem using the programming language python:
Two friends David and Rojer were preparing for their weekly class-test.
The are preparing for the math test, but because of continuously adding big integers and solving equations they got exhausted. They decided to take break and play a game. They play a game which will help them in both(for having fun and will also help to prepare for math test).
There are N words and they have to find RESULT with the help of these words (just like they have N integers and they have to find integer RESULT=sum of N integers) . Since they are playing this game for the first time! They are not too good in this. Help them in finding weather their RESULT is correct or not.
NOTE:- Total number of unique characters in N words are not greater than 10. All input words and RESULT are in UPPER-CASE only!
Refer Here for how to add numbers : https://en.wikipedia.org/wiki/Verbal_arithmetic
-----Input:-----
- First line consist of an integer N (total number of words).
- Next N line contains words with which they have to find RESULT.
- Last line consist of the RESULT they found.
-----Output:-----
If RESULT is correct print true else print false.
-----Sample Input:-----
3
THIS
IS
TOO
FUNNY
-----Sample Output:-----
true
-----Constraints-----
- $2 \leq N \leq 10$
- $1 \leq Length of The word \leq 10$
- $1 \leq Length of The Result \leq 11$
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
def isSolvable( W, R):
LW, LR, F, ML, AW, V, LMap = len(W), len(R), set([w[0] for w in W+[R]]), max(map(len, W+[R])), W+[R], set(), {}
if LR < ML: return False
def dfs(d,i,c):
if d == ML: return c == 0
if i == len(W) + 1:
s = sum(LMap[w[-d-1]] if d < len(w) else 0 for w in W) + c
return dfs(d+1,0,s//10) if s % 10 == LMap[R[-d-1]] else False
if i < LW and d >= len(W[i]): return dfs(d,i+1,c)
ch = AW[i][-d-1]
if ch in LMap: return dfs(d,i+1,c)
for x in range((ch in F), 10):
if x not in V:
LMap[ch], _ = x, V.add(x)
if dfs(d,i+1,c): return True
V.remove(LMap.pop(ch))
return dfs(0,0,0)
n=int(input())
W=[]
for i in range(n):
W.append(str(input()))
R=input()
a=(isSolvable(W,R))
if a==True:
print("true")
else:
print("false")
``` | {
"language": "python",
"test_cases": [
{
"input": "3\nTHIS\nIS\nTOO\nFUNNY\n",
"output": "true\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/CHLG2020/problems/MATH88"
} | vfc_3702 |
apps | verifiable_code | 1216 | Solve the following coding problem using the programming language python:
Today Chef wants to evaluate the dishes of his $N$ students. He asks each one to cook a dish and present it to him.
Chef loves his secret ingredient, and only likes dishes with at least $X$ grams of it.
Given $N$, $X$ and the amount of secret ingredient used by each student $A_i$, find out whether Chef will like at least one dish.
-----Input:-----
- First line will contain $T$, number of testcases. Then the testcases follow.
- The first line of each testcase contains two integers $N$
(number of students) and $X$ (minimum amount of secret ingredient that a dish must contain for Chef to like it).
- The next line contains $N$ space separated integers, $A_i$ denoting the amount of secret ingredient used by the students in their dishes.
-----Output:-----
For each testcase, print a single string "YES" if Chef likes at least one dish. Otherwise, print "NO". (Without quotes).
-----Constraints:-----
- $1 \leq T \leq 100$
- $1 \leq N \leq 1000$
- $1 \leq X \leq 1000000$
- $1 \leq A_i \leq 1000000$
-----Sample Input:-----
3
5 100
11 22 33 44 55
5 50
10 20 30 40 50
5 45
12 24 36 48 60
-----Sample Output:-----
NO
YES
YES
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
t=int(input())
for i in range(t):
n,k=map(int,input().split())
m=list(map(int,input().split()))
a=0
for i in m:
if i>=k:
a=1
break
if a==1:
print('YES')
else:
print('NO')
``` | {
"language": "python",
"test_cases": [
{
"input": "3\n5 100\n11 22 33 44 55\n5 50\n10 20 30 40 50\n5 45\n12 24 36 48 60\n",
"output": "NO\nYES\nYES\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/PCJ18A"
} | vfc_3706 |
apps | verifiable_code | 1218 | Solve the following coding problem using the programming language python:
Richik$Richik$ has just completed his engineering and has got a job in one of the firms at Sabrina$Sabrina$ which is ranked among the top seven islands in the world in terms of the pay scale.
Since Richik$Richik$ has to travel a lot to reach the firm, the owner assigns him a number X$X$, and asks him to come to work only on the day which is a multiple of X$X$. Richik joins the firm on 1-st day but starts working from X-th day. Richik$Richik$ is paid exactly the same amount in Dollars as the day number. For example, if Richik$Richik$ has been assigned X=3$X = 3$, then he will be paid 3$3$ dollars and 6$6$ dollars on the 3rd$3rd$ and 6th$6th$ day on which he comes for work.
On N−th$N-th$ day, the owner calls up Richik$Richik$ and asks him not to come to his firm anymore. Hence Richik$Richik$ demands his salary of all his working days together. Since it will take a lot of time to add, Richik$Richik$ asks help from people around him, let's see if you can help him out.
-----Input:-----
- First line will contain T$T$, number of testcases. Then the testcases follow.
- Each testcase contains of a single line of input, two integers X,N$X, N$.
-----Output:-----
For each testcase, output in a single line which is the salary which Richik$Richik$ demands.
-----Constraints-----
- 1≤T≤1000$1 \leq T \leq 1000$
- 1≤X<=N≤107$1 \leq X<=N \leq 10^7$
-----Sample Input:-----
1
3 10
-----Sample Output:-----
18
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
t=int(input())
for i in range(t):
x,n=[int(g) for g in input().split()]
sal=0
day=x
while day<n:
sal=sal+day
day+=x
print(sal)
``` | {
"language": "python",
"test_cases": [
{
"input": "1\n3 10\n",
"output": "18\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/AARA2018/problems/ARMBH1"
} | vfc_3714 |
apps | verifiable_code | 1219 | Solve the following coding problem using the programming language python:
You have found $M$ different types of jewels in a mine and each type of jewel is present in an infinite number.
There are $N$ different boxes located at position $(1 ,2 ,3 ,...N)$.
Each box can collect jewels up to a certain number ( box at position $i$ have $i$ different partitions and each partition can collect at most one jewel of any type).
Boxes at odd positions are already fully filled with jewels while boxes at even positions are completely empty.
Print the total number of different arrangements possible so that all boxes can be fully filled.
As the answer can be very large you can print it by doing modulo with 1000000007(10^9+7).
-----Input:-----
- First line will contain $T$, number of testcases.
- Each testcase contains of a single line of input, two integers $N , M$.
-----Output:-----
For each testcase, Print the total number of different arrangement.
-----Constraints-----
- $1 \leq T \leq 20000$
- $1 \leq N \leq 1e9$
- $1 \leq M \leq 1e14$
-----Sample Input:-----
2
1 10
5 2
-----Sample Output:-----
1
64
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:
M = 1000000007
n, m = list(map(int, input().split()))
ans = 1
tt = n//2
tt = tt * (tt + 1)
ans = pow(m, tt, M)
print(ans)
t -= 1
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n1 10\n5 2\n",
"output": "1\n64\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/INRO2021/problems/JEWELMIN"
} | vfc_3718 |
apps | verifiable_code | 1220 | Solve the following coding problem using the programming language python:
Lets wish Horsbug98 on his birthday and jump right into the question.
In Chefland, $6$ new mobile brands have appeared each providing a range of smartphones. For simplicity let the brands be represented by numbers $1$ to $6$. All phones are sold at the superstore.
There are total $N$ smartphones. Let $P_i$ & $B_i$ be the price and the brand of the $i^{th}$ smartphone. The superstore knows all the price and brand details beforehand.
Each customer has a preference for brands. The preference is a subset of the brands available (i.e $1$ to $6$). Also, the customer will buy the $K^{th}$ costliest phone among all the phones of his preference.
You will be asked $Q$ queries. Each query consists of the preference of the customer and $K$.
Find the price the customer has to pay for his preference. If no such phone is available, print $-1$
Note that for each query the total number of smartphones is always $N$ since, after each purchase, the phones are replaced instantly.
-----Input:-----
- First Line contains $N$ and $Q$
- Second-line contains $N$ integers $P_1,P_2,...,P_N$ (Price)
- Third line contains $N$ integers $B_1,B_2,...,B_N$ (Brand)
- Each of the next Q lines contains a query, the query is describes below
- First line of each quey contains $b$ and $K$ where $b$ is the size of the preference subset.
- Second line of each query contains $b$ integers, describing the preference subset.
-----Output:-----
For each query, print the price to be paid.
-----Constraints-----
- $1 \leq N, Q, P_i \leq 10^5$
- $1 \leq B_i, b \leq 6$
- $1 \leq K \leq N$
-----Sample Input:-----
4 2
4 5 6 7
1 2 3 4
3 3
1 2 3
3 4
4 5 6
-----Sample Output:-----
4
-1
-----Explaination-----
Query 1: The preference subset is {1, 2, 3}, The prices of phones available of these brands are {4, 5, 6}. The third costliest phone is 4.
Query 2: The preference subset is {4, 5, 6}, The prices of phones available of these brands are {7}.
Fouth costliest phone is required, which is not available. Hence, answer is $-1$.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
import sys
from collections import defaultdict
from copy import copy
R = lambda t = int: t(eval(input()))
RL = lambda t = int: [t(x) for x in input().split()]
RLL = lambda n, t = int: [RL(t) for _ in range(n)]
def solve():
N, Q = RL()
P = RL()
B = RL()
phones = sorted(zip(P, B))
S = defaultdict(lambda : [])
for p, b in phones:
for i in range(2**7):
if (i>>b) & 1:
S[i] += [p]
B = set(B)
I = [0] * len(B)
for _ in range(Q):
b, K = RL()
s = RL()
x = 0
for b in s:
x += 1<<b
if len(S[x]) < K:
print(-1)
else:
print(S[x][-K])
T = 1#R()
for t in range(1, T + 1):
solve()
``` | {
"language": "python",
"test_cases": [
{
"input": "4 2\n4 5 6 7\n1 2 3 4\n3 3\n1 2 3\n3 4\n4 5 6\n",
"output": "4\n-1\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/ENJU2020/problems/ECJN209"
} | vfc_3722 |
apps | verifiable_code | 1221 | Solve the following coding problem using the programming language python:
Chef played an interesting game yesterday. This game is played with two variables $X$ and $Y$; initially, $X = Y = 0$. Chef may make an arbitrary number of moves (including zero). In each move, he must perform the following process:
- Choose any positive integer $P$ such that $P \cdot P > Y$.
- Change $X$ to $P$.
- Add $P \cdot P$ to $Y$.
Unfortunately, Chef has a bad memory and he has forgotten the moves he made. He only remembers the value of $X$ after the game finished; let's denote it by $X_f$. Can you tell him the maximum possible number of moves he could have made in the game?
-----Input-----
- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
- The first and only line of each test case contains a single integer $X_f$.
-----Output-----
For each test case, print a single line containing one integer — the maximum number of moves Chef could have made.
-----Constraints-----
- $1 \le T \le 10^5$
- $1 \le X_f \le 10^9$
-----Example Input-----
3
3
8
9
-----Example Output-----
3
5
6
-----Explanation-----
Example case 2: One possible sequence of values of $X$ is $0 \rightarrow 1 \rightarrow 2 \rightarrow 3 \rightarrow 5 \rightarrow 8$.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
from math import sqrt
T = int(input())
ans = []
for _ in range(T):
X = int(input())
count = 0
x = 0
y = 0
while(x<=X):
p = int(sqrt(y))
count += 1
if(p*p>y):
x = p
y += p**2
else:
x = p+1
y += (p+1)**2
if(x<=X):
ans.append(count)
else:
ans.append(count-1)
for i in ans:
print(i)
``` | {
"language": "python",
"test_cases": [
{
"input": "3\n3\n8\n9\n",
"output": "3\n5\n6\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/TWOVRIBL"
} | vfc_3726 |
apps | verifiable_code | 1222 | Solve the following coding problem using the programming language python:
The EEE classes are so boring that the students play games rather than paying attention during the lectures. Harsha and Dubey are playing one such game.
The game involves counting the number of anagramic pairs of a given string (you can read about anagrams from here). Right now Harsha is winning. Write a program to help Dubey count this number quickly and win the game!
-----Input-----
The first line has an integer T which is the number of strings. Next T lines each contain a strings. Each string consists of lowercase english alphabets only.
-----Output-----
For each string, print the answer in a newline.
-----Constraints-----
- 1 ≤ T ≤ 1000
- 1 ≤ length of each string ≤ 100
-----Example-----
Input:
3
rama
abba
abcd
Output:
2
4
0
-----Explanation-----
rama has the following substrings:
- r
- ra
- ram
- rama
- a
- am
- ama
- m
- ma
- a
Out of these, {5,10} and {6,9} are anagramic pairs.
Hence the answer is 2.
Similarly for other strings as well.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
def sort_str(s):
o = []
for c in s:
o.append(c)
o.sort()
return "".join(o)
def find_ana(s):
if len(s) <= 1:
return 0
h = {}
c = 0
for i in range(len(s)):
for j in range(i+1, len(s)+1):
t = sort_str(s[i:j])
if t in h:
c += h[t]
h[t] += 1
else:
h[t] = 1
return c
t = int(input())
for _ in range(t):
print(find_ana(input()))
``` | {
"language": "python",
"test_cases": [
{
"input": "3\nrama\nabba\nabcd\n",
"output": "2\n4\n0\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/COCU2016/problems/CURR2"
} | vfc_3730 |
apps | verifiable_code | 1223 | Solve the following coding problem using the programming language python:
It's the annual military parade, and all the soldier snakes have arrived at the parade arena, But they aren't standing properly. The entire parade must be visible from the main podium, and all the snakes must be in a line. But the soldiers are lazy, and hence you must tell the soldiers to move to their new positions in such a manner that the total movement is minimized.
Formally, the entire parade strip can be thought of as the integer line. There are N snakes, where each snake is a line segment of length L. The i-th snake is initially at the segment [Si, Si + L]. The initial positions of the snakes can overlap. The only segment of the strip visible from the podium is [A, B], and hence all the snakes should be moved so that all of them are visible from the podium. They should also all be in a line without gaps and every consecutive pair touching each other. In other words, they should occupy the segments [X, X + L], [X + L, X + 2*L], ... , [X + (N-1)*L, X + N*L], for some X, such that A ≤ X ≤ X + N*L ≤ B. You are guaranteed that the visible strip is long enough to fit all the snakes.
If a snake was initially at the position [X1, X1 + L] and finally is at the position [X2, X2 + L], then the snake is said to have moved a distance of |X2 - X1|. The total distance moved by the snakes is just the summation of this value over all the snakes. You need to move the snakes in such a manner that it satisfies all the conditions mentioned above, as well as minimize the total distance. You should output the minimum total distance achievable.
-----Input-----
- The first line contains a single integer, T, the number of testcases. The description of each testcase follows.
- The first line of each testcase contains four integers, N, L, A and B, where N denotes the number of snakes, L denotes the length of each snake, and [A, B] is the segment visible from the podium.
- The next line contains N integers, the i-th of which is Si. This denotes that the i-th snake is initially in the segment [Si, Si + L].
-----Output-----
- For each testcase, output a single integer in a new line: the minimum total distance achievable.
-----Constraints-----
- 1 ≤ T ≤ 10
- 1 ≤ N ≤ 105
- 1 ≤ Si ≤ 109
- 1 ≤ L ≤ 109
- 1 ≤ A ≤ B ≤ 109
- N * L ≤ B - A
-----Example-----
Input:
2
3 4 11 23
10 11 30
3 4 11 40
10 11 30
Output:
16
16
-----Explanation-----
In the first testcase, the three snakes are initially at segments [10, 14], [11, 15], and [30, 34]. One optimal solution is to move the first snake which was at [10, 14] to [15, 19] and the third snake which was at [30, 34] to [19, 23]. After this, the snakes would form a valid parade because they will be from [11, 15], [15, 19] and [19, 23]. Hence they are all in a line without any gaps in between them, and they are all visible, because they all lie in the visible segment, which is [11, 23].
The distance traveled by the first snake is |15 - 10| = 5, by the second snake is |11 - 11| = 0 and by the third snake is |19 - 30| = 11. Hence the total distance traveled is 5 + 0 + 11 = 16. This is the best that you can do, and hence the answer is 16.
In the second testcase, only the visible segment has increased. But you can check that the same final configuration as in the first subtask is still optimal here. Hence the answer is 16.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
t=int(input())
def vsense(val,a,l):
sense=0
ctr=a
for c in range(n):
if val[c]<=ctr:
sense+=-1
else:
sense+=1
ctr+=l
return sense
while t:
n,l,a,b=list(map(int,input().split()))
val=list(map(int,input().split()))
val.sort()
sense=0
if b==a+n*l or vsense(val,a,l)<=0:
loc=a
else:
st=a
end=b-n*l
while st<=end:
m=(st+end)/2
chk=vsense(val,m,l)
if chk==0:
loc=m
break
elif chk<0:
end=m-1
else:
loc=m
st=m+1
ans=0
st=loc
for c in range(n):
ans+=abs(st-val[c])
st+=l
print(ans)
t-=1
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n3 4 11 23\n10 11 30\n3 4 11 40\n10 11 30\n",
"output": "16\n16\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/CONSESNK"
} | vfc_3734 |
apps | verifiable_code | 1224 | Solve the following coding problem using the programming language python:
Eugene loves sequences, especially arithmetic progressions. One day he was asked to solve a difficult problem.
If a sequence of numbers A1, A2, ... , AN form an arithmetic progression A, he was asked to calculate sum of F(Ai), for L ≤ i ≤ R.
F(X) is defined as:
If X < 10 then F(X) = X.
Else F(X) = F(sum_of_digits(X)).
Example:
F(1378) =
F(1+3+7+8) =
F(19) =
F(1 + 9) =
F(10) =
F(1+0) =
F(1) = 1
-----Input-----
- The first line of the input contains an integer T denoting the number of test cases.
- Each test case is described in one line containing four integers: A1 denoting the first element of the arithmetic progression A, D denoting the common difference between successive members of A, and L and R as described in the problem statement.
-----Output-----
- For each test case, output a single line containing one integer denoting sum of F(Ai).
-----Constraints-----
- 1 ≤ T ≤ 105
- 1 ≤ A1 ≤ 109
- 0 ≤ D ≤ 109
- 1 ≤ R ≤ 1018
- 1 ≤ L ≤ R
-----Subtasks-----
- Subtask 1: 0 ≤ D ≤ 100, 1 ≤ A1 ≤ 109, 1 ≤ R ≤ 100 - 15 points
- Subtask 2: 0 ≤ D ≤ 109, 1 ≤ A1 ≤ 109, 1 ≤ R ≤ 106 - 25 points
- Subtask 3: Original constraints - 60 points
-----Example-----
Input:
2
1 1 1 3
14 7 2 4
Output:
6
12
-----Explanation-----
Example case 1.
A = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, ...}
A1 = 1
A2 = 2
A3 = 3
F(A1) = 1
F(A2) = 2
F(A3) = 3
1+2+3=6
Example case 2.
A = {14, 21, 28, 35, 42, 49, 56, 63, 70, 77, ...}
A2 = 21
A3 = 28
A4 = 35
F(A2) = 3
F(A3) = 1
F(A4) = 8
3+1+8=12
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
import fractions
import sys
f = sys.stdin
if len(sys.argv) > 1:
f = open(sys.argv[1], "rt")
sum_cache = {}
def sum_func(x):
if x < 10:
return x
r = sum_cache.get(x)
if r is not None:
return r
xx = 0
while x > 0:
xx += x % 10
x /= 10
r = sum_func(xx)
sum_cache[x] = r
return r
def test():
for n in range(1):
print(n, sum_func(n))
print(sum_func(int(10**18 - 1)))
#~ test()
#~ sys.exit(1)
cycle_table = [
# Cycle len, markers # D_kfunc
[9, [1, 1, 1, 1, 1, 1, 1, 1, 1]], # 1
[9, [1, 1, 1, 1, 1, 1, 1, 1, 1]], # 2
[3, [1, 0, 0, 1, 0, 0, 1, 0, 0]], # 3
[9, [1, 1, 1, 1, 1, 1, 1, 1, 1]], # 4
[9, [1, 1, 1, 1, 1, 1, 1, 1, 1]], # 5
[3, [1, 0, 0, 1, 0, 0, 1, 0, 0]], # 6
[9, [1, 1, 1, 1, 1, 1, 1, 1, 1]], # 7
[9, [1, 1, 1, 1, 1, 1, 1, 1, 1]], # 8
[1, [1, 0, 0, 0, 0, 0, 0, 0, 0]], # 9
]
NUMBER = 9
def calc(A_1, D, L, R):
#~ print('calc ===', A_1, D, L, R)
A_L = A_1 + D * (L - 1)
A_L_kfunc = sum_func(A_L)
D_kfunc = sum_func(D)
#~ print(A_L, A_L_kfunc, D_kfunc)
n = R - L + 1
if D == 0:
return n * A_L_kfunc
cycle_len = cycle_table[D_kfunc - 1][0]
cycle_markers = list(cycle_table[D_kfunc - 1][1]) # copy
#~ print('cycle_len', cycle_len)
whole_part = n // cycle_len
remainder = n % cycle_len
#~ print('whole_part, remainder = ', whole_part, remainder)
counts = [whole_part * x for x in cycle_markers]
#~ print(counts)
pos = 0
for i in range(remainder):
counts[pos] += 1
pos = (pos + D_kfunc) % NUMBER
#~ print(counts)
r = 0
for i, x in enumerate(counts):
value = (A_L_kfunc - 1 + i) % NUMBER + 1
r += value * x
return r
def calc_dumb(A_1, D, L, R):
#~ print('dumb ===', A_1, D, L, R)
a = A_1 + D * (L - 1)
n = R - L + 1
r = 0
for i in range(n):
value = sum_func(a)
#~ print(a, value)
r += value
a += D
return r
def test1():
a1 = 1
L = 1
R = 1000
for d in range(100):
r1 = calc_dumb(a1, d, L, R)
r2 = calc(a1, d, L, R)
if r1 != r2:
print(a1, d, L, R, ":", r1, r2)
def test2():
a1 = 1
d = 9
L = 1
R = 9
r1 = calc_dumb(a1, d, L, R)
r2 = calc(a1, d, L, R)
print(r1, r2)
#~ test1()
#~ sys.exit(1)
T = int(f.readline().strip())
for case_id in range(1, T+1):
A_1, D, L, R = list(map(int, f.readline().strip().split()))
r = calc(A_1, D, L, R)
print(r)
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n1 1 1 3\n14 7 2 4\n\n\n",
"output": "6\n12\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/NOV15/problems/KFUNC"
} | vfc_3738 |
apps | verifiable_code | 1225 | Solve the following coding problem using the programming language python:
Tomya is a girl. She loves Chef Ciel very much.
Today, too, Tomya is going to Ciel's restaurant.
Of course, Tomya would like to go to Ciel's restaurant as soon as possible.
Therefore Tomya uses one of the shortest paths from Tomya's house to Ciel's restaurant.
On the other hand, Tomya is boring now to use the same path many times.
So Tomya wants to know the number of shortest paths from Tomya's house to Ciel's restaurant.
Your task is to calculate the number under the following assumptions.
This town has N intersections and M two way roads.
The i-th road connects from the Ai-th intersection to the Bi-th intersection, and its length is
Ci.
Tomya's house is in the 1st intersection, and Ciel's restaurant is in the N-th intersection.
-----Input-----
The first line contains an integer T, the number of test cases.
Then T test cases follow.
The first line of each test case contains 2 integers N, M.
Then next M lines contains 3 integers denoting Ai, Bi and Ci.
-----Output-----
For each test case, print the number of shortest paths from Tomya's house to Ciel's restaurant.
-----Constraints-----
1 ≤ T ≤ 10
2 ≤ N ≤ 10
1 ≤ M ≤ N ∙ (N – 1) / 2
1 ≤ Ai, Bi ≤ N
1 ≤ Ci ≤ 10
Ai ≠ Bi
If i ≠ j and Ai = Aj, then Bi ≠ Bj
There is at least one path from Tomya's house to Ciel's restaurant.
-----Sample Input-----
2
3 3
1 2 3
2 3 6
1 3 7
3 3
1 2 3
2 3 6
1 3 9
-----Sample Output-----
1
2
-----Explanations-----
In the first sample, only one shortest path exists, which is 1-3.
In the second sample, both paths 1-2-3 and 1-3 are the shortest paths.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
t=eval(input())
def func(k,n,x,dist,graph):
if k==n:
x+=[dist[n]]
return
for i in range(1,n+1):
if graph[k][i]!=0 and dist[i]==-1:
dist[i]=dist[k]+graph[k][i]
func(i,n,x,dist,graph)
dist[i]=-1
while t:
graph=[[0 for i in range(11)]for j in range(11)]
v,e=list(map(int,input().split()))
for i in range(e):
x,y,w=list(map(int,input().split()))
graph[x][y]=w
graph[y][x]=w
x=[]
dist=[-1]*(v+1)
dist[1]=0
func(1,v,x,dist,graph)
x.sort()
val=x[0]
ans=0
for i in range(len(x)):
if val==x[i]:
ans+=1
print(ans)
t-=1
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n3 3\n1 2 3\n2 3 6\n1 3 7\n3 3\n1 2 3\n2 3 6\n1 3 9\n",
"output": "1\n2\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/CIELTOMY"
} | vfc_3742 |
apps | verifiable_code | 1226 | Solve the following coding problem using the programming language python:
It is well-known that the elephants are afraid of mouses. The Little Elephant from the Zoo of Lviv is not an exception.
The Little Elephant is on a board A of n rows and m columns (0-based numeration). At the beginning he is in cell with coordinates (0; 0) and he wants to go to cell with coordinates (n-1; m-1). From cell (x; y) Little Elephant can go either to (x+1; y) or (x; y+1).
Each cell of the board contains either 1 or 0. If A[i][j] = 1, then there is a single mouse in cell (i; j). Mouse at cell (i; j) scared Little Elephants if and only if during the path there was at least one such cell (x; y) (which belongs to that path) and |i-x| + |j-y| <= 1.
Little Elephant wants to find some correct path from (0; 0) to (n-1; m-1) such that the number of mouses that have scared the Little Elephant is minimal possible. Print that number.
-----Input-----
First line contains single integer T - the number of test cases. Then T test cases follow. First line of each test case contain pair of integers n and m - the size of the board. Next n lines contain n strings, each of size m and consisted of digits 0 and 1.
-----Output-----
In T lines print T integer - the answers for the corresponding test.
-----Constraints-----
1 <= T <= 50
2 <= n, m <= 100
-----Example-----
Input:
2
3 9
001000001
111111010
100100100
7 9
010101110
110110111
010011111
100100000
000010100
011011000
000100101
Output:
9
10
-----Explanation-----
Example case 1:
The optimized path is: (0, 0) -> (0, 1) -> (0, 2) -> (0, 3) -> (0, 4) -> (0, 5) -> (0, 6) -> (0, 7) -> (0, 8) -> (1, 8) -> (2, 8). The mouses that scared the Little Elephant are at the following cells: (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 7), (0, 2), (0, 8).
Example case 2:
The optimized path is: (0, 0) -> (1, 0) -> (1, 1) -> (2, 1) -> (2, 2) -> (3, 2) -> (3, 3) -> (4, 3) -> (4, 4) -> (5, 4) -> (5, 5) -> (6, 5) -> (6, 6) -> (6, 7) -> (6, 8). The 10 mouses that scared the Little Elephant are at the following cells: (0, 1), (1, 0), (1, 1), (2, 1), (3, 3), (4, 4), (5, 4), (5, 5), (6, 6), (6, 8).
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
from collections import defaultdict
from itertools import product
def solve(mouse,n,m):
# shadow matrix will contains the count of mice which affect (i,j) position
# if there is a mice at position (i,j) then in shadow matrix it will affect all four adjacent blocks
shadow=[[0 for i in range(m)]for j in range(n)]
for i,j in product(list(range(n)),list(range(m))):
if mouse[i][j]==1:
if i>0:
shadow[i-1][j]+=1
if j>0:
shadow[i][j-1]+=1
if i<n-1:
shadow[i+1][j]+=1
if j<m-1:
shadow[i][j+1]+=1
# dp is a dictionary which contains a tuple of 3 values (i,j,0)=>we are coming at destination (i,j) from left side
# (i,j,1)=> we are coming at destination (i,j) from top
dp=defaultdict(int)
#
dp[(0,0,0)]=dp[(0,0,1)]=shadow[0][0]-mouse[0][0]
# fill only first row
# in first row we can only reach at (0,j) from (0,j-1,0) as we can't come from top.
# so here we will assign count of mices which will affect current cell (shadow[0][i]) + previous result i.e,(0,j-1,0) and
# if mouse is in the current cell than we have to subtract it bcoz we have add it twice i.e, when we enter at this block
# and when we leave this block
for i in range(1,m):
dp[(0,i,0)]=dp[(0,i,1)]=shadow[0][i]-mouse[0][i]+dp[(0,i-1,0)]
# same goes for first column
# we can only come at (i,0) from (i-1,0) i.e top
for i in range(1,n):
dp[(i,0,0)]=dp[(i,0,1)]=shadow[i][0]-mouse[i][0]+dp[(i-1,0,1)]
# for rest of the blocks
# for a block (i,j) we have to add shadow[i][j] and subtract mouse[i][j] from it for double counting
# now for each block we have two choices, either take its previous block with same direction or take previous block with different
# direction and subtract corner double counted mouse. We have to take min of both to find optimal answer
for i,j in product(list(range(1,n)),list(range(1,m))):
a=shadow[i][j]-mouse[i][j]
b=a
a+=min(dp[(i,j-1,0)],dp[(i,j-1,1)]-mouse[i-1][j])
b+=min(dp[(i-1,j,1)],dp[(i-1,j,0)]-mouse[i][j-1])
dp[(i,j,0)]=a
dp[(i,j,1)]=b
# what if [0][0] and [n-1][m-1] have mice, so we have to add them as we haven't counted them yet.
return min(dp[(n-1,m-1,0)],dp[(n-1,m-1,1)])+mouse[0][0]+mouse[n-1][m-1]
for _ in range(int(input())):
n,m=list(map(int,input().split( )))
mouse=[]
for i in range(n):
x=input()
mouse.append(list(map(int,x)))
print(solve(mouse,n,m))
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n3 9\n001000001\n111111010\n100100100\n7 9\n010101110\n110110111\n010011111\n100100000\n000010100\n011011000\n000100101\n",
"output": "9\n10\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/LEMOUSE"
} | vfc_3746 |
apps | verifiable_code | 1227 | Solve the following coding problem using the programming language python:
One day, Chef found a cube which has each of its sides painted in some color out of black, blue, red, green, yellow and orange.
Now he asks you to check if he can choose three sides such that they are pairwise adjacent and painted in the same color.
-----Input-----
- The first line of the input contains an integer T denoting the number of test cases.
- A single line of each test case contains six words denoting the colors of painted sides in the order: front, back, left, right, top and bottom, respectively.
-----Output-----
For each test case, output a single line containing the word "YES" or "NO" (without quotes) corresponding to the answer of the problem.
-----Constraints-----
- 1 ≤ T ≤ 50000
- Each color will be from the list {"black", "blue", "red", "green", "yellow", "orange"}
-----Subtasks-----
Subtask 1: (25 points)
- 1 ≤ T ≤ 12000
- For each test case there will be at most three different colors
Subtask 2: (75 points)
- Original constraints
-----Example-----
Input:
2
blue yellow green orange black green
green yellow green orange black green
Output:
NO
YES
-----Explanation-----
Example case 1.
There are no three sides with the same color.
Example case 2.
In this test case, the front, bottom and left sides are green (see picture).
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())):
l=list(map(str,input().split()))
a=[(1,3,5),(1,3,6),(1,4,5),(1,4,6),(2,3,5),(2,3,6),(2,4,5),(2,4,6)]
c=0
for i in a:
if len(set([l[i[0]-1],l[i[1]-1],l[i[2]-1]]))==1:
c=1
break
if c==1:
print("YES")
else:
print("NO")
``` | {
"language": "python",
"test_cases": [
{
"input": "2\nblue yellow green orange black green\ngreen yellow green orange black green\n",
"output": "NO\nYES\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/CHCUBE"
} | vfc_3750 |
apps | verifiable_code | 1228 | Solve the following coding problem using the programming language python:
Chef has $N$ axis-parallel rectangles in a 2D Cartesian coordinate system. These rectangles may intersect, but it is guaranteed that all their $4N$ vertices are pairwise distinct.
Unfortunately, Chef lost one vertex, and up until now, none of his fixes have worked (although putting an image of a point on a milk carton might not have been the greatest idea after all…). Therefore, he gave you the task of finding it! You are given the remaining $4N-1$ points and you should find the missing one.
-----Input-----
- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
- The first line of each test case contains a single integer $N$.
- Then, $4N-1$ lines follow. Each of these lines contains two space-separated integers $x$ and $y$ denoting a vertex $(x, y)$ of some rectangle.
-----Output-----
For each test case, print a single line containing two space-separated integers $X$ and $Y$ ― the coordinates of the missing point. It can be proved that the missing point can be determined uniquely.
-----Constraints-----
- $T \le 100$
- $1 \le N \le 2 \cdot 10^5$
- $|x|, |y| \le 10^9$
- the sum of $N$ over all test cases does not exceed $2 \cdot 10^5$
-----Subtasks-----
Subtask #1 (20 points):
- $T = 5$
- $N \le 20$
Subtask #2 (30 points): $|x|, |y| \le 10^5$
Subtask #3 (50 points): original constraints
-----Example Input-----
1
2
1 1
1 2
4 6
2 1
9 6
9 3
4 3
-----Example Output-----
2 2
-----Explanation-----
The original set of points are:
Upon adding the missing point $(2, 2)$, $N = 2$ rectangles can be formed:
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
for _ in range(int(input())):
n=int(input())
a=[]
b=[]
for i in range(4*n-1):
c,d=list(map(int,input().split()))
a.append(c)
b.append(d)
c1=0
c2=0
for i in a:
c1^=i
for i in b:
c2^=i
print(c1,c2)
``` | {
"language": "python",
"test_cases": [
{
"input": "1\n2\n1 1\n1 2\n4 6\n2 1\n9 6\n9 3\n4 3\n",
"output": "2 2\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/PTMSSNG"
} | vfc_3754 |
apps | verifiable_code | 1229 | Solve the following coding problem using the programming language python:
Motu and Tomu are very good friends who are always looking for new games to play against each other and ways to win these games. One day, they decided to play a new type of game with the following rules:
- The game is played on a sequence $A_0, A_1, \dots, A_{N-1}$.
- The players alternate turns; Motu plays first, since he's earlier in lexicographical order.
- Each player has a score. The initial scores of both players are $0$.
- On his turn, the current player has to pick the element of $A$ with the lowest index, add its value to his score and delete that element from the sequence $A$.
- At the end of the game (when $A$ is empty), Tomu wins if he has strictly greater score than Motu. Otherwise, Motu wins the game.
In other words, Motu starts by selecting $A_0$, adding it to his score and then deleting it; then, Tomu selects $A_1$, adds its value to his score and deletes it, and so on.
Motu and Tomu already chose a sequence $A$ for this game. However, since Tomu plays second, he is given a different advantage: before the game, he is allowed to perform at most $K$ swaps in $A$; afterwards, the two friends are going to play the game on this modified sequence.
Now, Tomu wants you to determine if it is possible to perform up to $K$ swaps in such a way that he can win this game.
-----Input-----
- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
- The first line of each test case contains two space-separated integers $N$ and $K$ denoting the number of elements in the sequence and the maximum number of swaps Tomu can perform.
- The second line contains $N$ space-separated integers $A_0, A_1, \dots, A_{N-1}$.
-----Output-----
For each test case, print a single line containing the string "YES" if Tomu can win the game or "NO" otherwise (without quotes).
-----Constraints-----
- $1 \le T \le 100$
- $1 \le N \le 10,000$
- $0 \le K \le 10,000$
- $1 \le A_i \le 10,000$ for each valid $i$
-----Subtasks-----
Subtask #1 (20 points): $1 \le N \le 100$
Subtask #2 (80 points): original constraints
-----Example Input-----
2
6 0
1 1 1 1 1 1
5 1
2 4 6 3 4
-----Example Output-----
NO
YES
-----Explanation-----
Example case 1: At the end of the game, both Motu and Tomu will have scores $1+1+1 = 3$. Tomu is unable to win that game, so the output is "NO".
Example case 2: If no swaps were performed, Motu's score would be $2+6+4 = 12$ and Tomu's score would be $4+3 = 7$. However, Tomu can swap the elements $A_2 = 6$ and $A_3 = 3$, which makes Motu's score at the end of the game equal to $2+3+4 = 9$ and Tomu's score equal to $4+6 = 10$. Tomu managed to score higher than Motu, so the 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
for _ in range(int(input())):
n, k = map(int, input().split())
arr= list(map(int, input().split()))
motu, tomu = [], []
for i in range(n):
if i%2 == 0:
motu.append(arr[i])
else:
tomu.append((arr[i]))
motu.sort(reverse=True)
tomu.sort()
for i in range(len(motu)):
if len(tomu)-1<i:
break
if k==0:
break
if tomu[i]<motu[i]:
tomu[i], motu[i] = motu[i], tomu[i]
k-=1
if sum(tomu) > sum(motu):
print("YES")
else:
print("NO")
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n6 0\n1 1 1 1 1 1\n5 1\n2 4 6 3 4\n",
"output": "NO\nYES\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/MTYFRI"
} | vfc_3758 |
apps | verifiable_code | 1230 | Solve the following coding problem using the programming language python:
The Gray code (see wikipedia for more details) is a well-known concept.
One of its important properties is that every two adjacent numbers have exactly one different digit in their binary representation.
In this problem, we will give you n non-negative integers in a sequence A[1..n] (0<=A[i]<2^64), such that every two adjacent integers have exactly one different digit in their binary representation, similar to the Gray code.
Your task is to check whether there exist 4 numbers A[i1], A[i2], A[i3], A[i4] (1 <= i1 < i2 < i3 < i4 <= n) out of the given n numbers such that A[i1] xor A[i2] xor A[i3] xor A[i4] = 0. Here xor is a bitwise operation which is same as ^ in C, C++, Java and xor in Pascal.
-----Input-----
First line contains one integer n (4<=n<=100000).
Second line contains n space seperated non-negative integers denoting the sequence A.
-----Output-----
Output “Yes” (quotes exclusive) if there exist four distinct indices i1, i2, i3, i4 such that A[i1] xor A[i2] xor A[i3] xor A[i4] = 0. Otherwise, output "No" (quotes exclusive) please.
-----Example-----
Input:
5
1 0 2 3 7
Output:
Yes
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
dic = {}
#num = "1"
#def tonum(num):
# res=0
# for i in range(len(num)):
# res = 2*res + int(num[i])
# return res
#for i in range(64):
# number = tonum(num)
# dic[num] = []
# num = num+"0"
n = int(input())
flag=0
if n >= 68:
inp = input()
print("Yes")
else:
inp = [int(x) for x in input().split()]
for i in range(len(inp)-1):
for j in range(i+1,len(inp)):
xor = inp[i]^inp[j]
if xor in list(dic.keys()):
for pair in dic[xor]:
(x,y) = pair
if x != i and y!=j and x!=j and y!=i:
flag = 1
break
dic[xor].append((i,j))
else:
dic[xor] = []
dic[xor].append((i,j))
if flag is 1:
break
if flag is 1:
break
if flag is 1:
print("Yes")
else:
print("No")
``` | {
"language": "python",
"test_cases": [
{
"input": "5\n1 0 2 3 7\n",
"output": "Yes\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/JULY12/problems/GRAYSC"
} | vfc_3762 |
apps | verifiable_code | 1231 | Solve the following coding problem using the programming language python:
The chef won a duet singing award at Techsurge & Mridang 2012. From that time he is obsessed with the number 2.
He just started calculating the powers of two. And adding the digits of the results.
But he got puzzled after a few calculations. So gave you the job to generate the solutions to 2^n and find their sum of digits.
-----Input-----
N : number of inputs N<=100
then N lines with input T<=2000
-----Output-----
The output for the corresponding input T
-----Example-----
Input:
3
5
10
4
Output:
5
7
7
Explanation:
2^5=32
3+2=5
2^10=1024
1+0+2+4=7
2^4=16
1+6=7
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
from operator import add
from functools import reduce
choices=[]
for x in range(1800):
num_str = list(map (int, str (2**x)))
suma = reduce (add, num_str)
choices.append(suma)
N=int(input())
for x in range(N):
t=int(input())
print(choices[t])
``` | {
"language": "python",
"test_cases": [
{
"input": "3\n5\n10\n4\n",
"output": "5\n7\n7\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/AGTK2012/problems/ALG2N"
} | vfc_3766 |
apps | verifiable_code | 1232 | Solve the following coding problem using the programming language python:
AND gates and OR gates are basic components used in building digital circuits. Both gates have two input lines and one output line. The output of an AND gate is 1 if both inputs are 1, otherwise the output is 0. The output of an OR gate is 1 if at least one input is 1, otherwise the output is 0.
You are given a digital circuit composed of only AND and OR gates where one node (gate or input) is specially designated as the output. Furthermore, for any gate G and any input node I, at most one of the inputs to G depends on the value of node I.
Now consider the following random experiment. Fix some probability p in [0,1] and set each input bit to 1 independently at random with probability p (and to 0 with probability 1-p). The output is then 1 with some probability that depends on p. You wonder what value of p causes the circuit to output a 1 with probability 1/2.
-----Input-----
The first line indicates the number of test cases to follow (about 100).
Each test case begins with a single line containing a single integer n with 1 ≤ n ≤ 100 indicating the number of nodes (inputs and gates) in the circuit. Following this, n lines follow where the i'th line describes the i'th node. If the node is an input, the line simply consists of the integer 0. Otherwise, if the node is an OR gate then the line begins with a 1 and if the node is an AND gate then the line begins with a 2. In either case, two more integers a,b follow, both less than i, which indicate that the outputs from both a and b are used as the two input to gate i.
As stated before, the circuit will be such that no gate has both of its inputs depending on the value of a common input node.
Test cases are separated by a blank line including a blank line preceding the first test case.
-----Output-----
For each test case you are to output a single line containing the value p for which the output of node n is 1 with probability exactly 1/2 if the inputs are independently and randomly set to value 1 with probability p. The value p should be printed with exactly 5 digits after the decimal.
-----Example-----
Input:
4
1
0
3
0
0
1 1 2
3
0
0
2 1 2
5
0
0
0
2 1 2
1 3 4
Output:
0.50000
0.29289
0.70711
0.40303
-----Temporary Stuff-----
A horizontal rule follows.
***
Here's a definition list (with `definitionLists` option):
apples
: Good for making applesauce.
oranges
: Citrus!
tomatoes
: There's no "e" in tomatoe.
#PRACTICE
- This must be done
[http:codechef.com/users/dpraveen](http:codechef.com/users/dpraveen)
(0.8944272−0.44721360.4472136−0.8944272)(10005)(0.89442720.4472136−0.4472136−0.8944272)(10005)
\left(\begin{array}{cc}
0.8944272 & 0.4472136\\
-0.4472136 & -0.8944272
\end{array}\right)
\left(\begin{array}{cc}
10 & 0\\
0 & 5
\end{array}\right)
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
class node:
def __init__(self,a,b=0,c=0):
self.val=a
self.a=b
self.b=c
arr=[]
def finder(node,val):
if(arr[node].val==0):
return val
else:
a=finder(arr[node].a,val)
b=finder(arr[node].b,val)
if(arr[node].val==1):
return a+b-a*b
else:
return a*b
t=int(input())
while(t>0):
x=input()
n=int(input())
arr.append(node(0))
for i in range(0,n):
vals=input().split()
sz=len(vals)
for i in range(0,sz):
vals[i]=int(vals[i])
if(vals[0]==0):
next=node(0)
arr.append(next)
else:
next=node(vals[0],vals[1],vals[2])
arr.append(next)
lower=0.0
higher=1.0
eps=1e-9
while((higher-lower)>eps):
mid=(higher+lower)/2.0
if(finder(n,mid)>0.5):
higher=mid
else:
lower=mid
print("%.5f" %(higher))
arr=[]
# print(higher)
t-=1
``` | {
"language": "python",
"test_cases": [
{
"input": "4\n\n1\n0\n\n3\n0\n0\n1 1 2\n\n3\n0\n0\n2 1 2\n\n5\n0\n0\n0\n2 1 2\n1 3 4\n\n\n",
"output": "0.50000\n0.29289\n0.70711\n0.40303\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/CIRCUITS"
} | vfc_3770 |
apps | verifiable_code | 1233 | Solve the following coding problem using the programming language python:
There are players standing in a row each player has a digit written on their T-Shirt (multiple players can have the same number written on their T-Shirt).
You have to select a group of players, note that players in this group should be standing in $\textbf{consecutive fashion}$. For example second player of chosen group next to first player of chosen group, third player next to second and similarly last player next to second last player of chosen group. Basically You've to choose a contiguous group of players.
After choosing a group, players can be paired if they have the same T-Shirt number (one player can be present in at most one pair), finally the chosen group is called “good” if at most one player is left unmatched. Your task is to find the size of the maximum “good” group.
Formally, you are given a string $S=s_{1}s_{2}s_{3}...s_{i}...s_{n}$ where $s_{i}$ can be any digit character between $'0'$ and $'9'$ and $s_{i}$ denotes the number written on the T-Shirt of $i^{th}$ player. Find a value $length$ such that there exist pair of indices $(i,j)$ which denotes $S[i...j]$ is a “good” group where $i\geq1$ and $j\leq S.length$ and $i\leq j$ and $(j-i+1)=length$ and there exist no other pair $(i’,j’)$ such that $(j’-i’+1)>length$ and $S[i'...j']$ is a "good" group.
-----Input:-----
- First line will contain $T$, number of testcases. Then the testcases follow.
- $i^{th}$ testcase consist of a single line of input, a string $S$.
-----Output:-----
For each testcase, output in a single line maximum possible size of a "good" group.
-----Constraints-----
$\textbf{Subtask 1} (20 points)$
- $1 \leq T \leq 10$
- $S.length \leq 10^{3}$
$\textbf{Subtask 2} (80 points)$
- $1 \leq T \leq 10$
- $S.length \leq 10^{5}$
-----Sample Input:-----
1
123343
-----Sample Output:-----
3
-----EXPLANATION:-----
1$\textbf{$\underline{2 3 3}$}$43
Underlined group is a “good” group because the second player(number 2 on T-Shirt) is the only player who is left unmatched and third and fourth player can form a pair, no other group has length greater than 3 that are “good”. However note that we have other “good” group also 12$\textbf{$\underline{334}$}$3 but length is 3 which is same as our answer.
-----Sample Input:-----
1
95665
-----Sample Output:-----
5
-----EXPLANATION:-----
$\textbf{$\underline{95665}$}$ is “good” group because first player is the only player who is left unmatched second and fifth player can form pair and third and fourth player also form pair.
-----Sample Input:-----
2
2323
1234567
-----Sample Output:-----
4
1
-----EXPLANATION:-----
For first test case
$\textbf{$\underline{2323}$}$ is a “good” group because there are no players who are left unmatched first and third player form pair and second and fourth player form pair.
For second test
Only length one "good" group is possible.
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 GRIG(L):
LENT = len(L)
MINT = 1
GOT = 0
DY = [ [{x: 0 for x in range(0, 10)}, 0, 0] ]
for i in L:
DY.append([{x: 0 for x in range(0, 10)}, 0, 0])
GOT += 1
for j in range(0, GOT):
if DY[j][0][i] == 1:
DY[j][0][i] = 0
DY[j][1] -= 1
else:
DY[j][0][i] = 1
DY[j][1] += 1
DY[j][2] += 1
if DY[j][1] <= 1 and DY[j][2] > MINT:
MINT = DY[j][2]
return MINT
TESTCASES = int(input().strip())
for i in range(0, TESTCASES):
L = [int(x) for x in list(input().strip())]
print(GRIG(L))
``` | {
"language": "python",
"test_cases": [
{
"input": "1\n123343\n",
"output": "3\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/COVO2020/problems/GRIG"
} | vfc_3774 |
apps | verifiable_code | 1234 | Solve the following coding problem using the programming language python:
There is a new prodigy in town and he has challenged people to a game. They have to give him an integer N and he will immediately respond with a number which has more than N factors.
What the prodigy really does is to do some complex calculations in his head to find out the smallest integer with more than N factors. However, he has a weakness - he knows to do those calculation only on numbers up to 1019, so if the answer to be reported is more than 1019, he will not be able to come up with his solution and will lose the game.
Given the integer the people give to the prodigy, you need to report whether he wins the game or not. If he wins, also output his answer.
-----Input-----
The first line of input contains T (T ≤ 25), the number of test cases. Following this are T lines, each containing an integer N (1 ≤ N ≤ 109) - the number which is given to the prodigy.
-----Output-----
Output one line per test case. If the smallest integer X with more than N factors is bigger than 1019 so that the prodigy does not win, print "lose". Otherwise print "win X" (quotes for clarity).
-----Example-----
Input:
3
3
5
12345678
Output:
win 6
win 12
lose
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
divisors = [1 , 2 , 3 , 4 , 6 , 8 , 9 , 10 , 12 , 16 , 18 , 20 , 24 , 30 , 32 , 36 , 40 , 48 , 60 , 64 , 72 , 80 , 84 , 90 , 96 , 100 , 108 , 120 , 128 , 144 , 160 , 168 , 180 , 192 , 200 , 216 , 224 , 240 , 256 , 288 , 320 , 336 , 360 , 384 , 400 , 432 , 448 , 480 , 504 , 512 , 576 , 600 , 640 , 672 , 720 , 768 , 800 , 864 , 896 , 960 , 1008 , 1024 , 1152 , 1200 , 1280 , 1344 , 1440 , 1536 , 1600 , 1680 , 1728 , 1792 , 1920 , 2016 , 2048 , 2304 , 2400 , 2688 , 2880 , 3072 , 3360 , 3456 , 3584 , 3600 , 3840 , 4032 , 4096 , 4320 , 4608 , 4800 , 5040 , 5376 , 5760 , 6144 , 6720 , 6912 , 7168 , 7200 , 7680 , 8064 , 8192 , 8640 , 9216 , 10080 , 10368 , 10752 , 11520 , 12288 , 12960 , 13440 , 13824 , 14336 , 14400 , 15360 , 16128 , 16384 , 17280 , 18432 , 20160 , 20736 , 21504 , 23040 , 24576 , 25920 , 26880 , 27648 , 28672 , 28800 , 30720 , 32256 , 32768 , 34560 , 36864 , 40320 , 41472 , 43008 , 46080 , 48384 , 49152 , 51840 , 53760 , 55296 , 57600 , 61440 , 62208 , 64512 , 65536 , 69120 , 73728 , 80640 , 82944 , 86016 , 92160 , 96768 , 98304 , 103680 , 107520 , 110592 , 115200 , 122880 , 124416 , 129024 , 131072 , 138240 , 147456 , 153600 , 161280 , 165888 , 172032 , 184320 , 193536 , 196608 , 207360 , 215040 , 221184 , 230400 , 245760]
numbers = [1 , 2 , 4 , 6 , 12 , 24 , 36 , 48 , 60 , 120 , 180 , 240 , 360 , 720 , 840 , 1260 , 1680 , 2520 , 5040 , 7560 , 10080 , 15120 , 20160 , 25200 , 27720 , 45360 , 50400 , 55440 , 83160 , 110880 , 166320 , 221760 , 277200 , 332640 , 498960 , 554400 , 665280 , 720720 , 1081080 , 1441440 , 2162160 , 2882880 , 3603600 , 4324320 , 6486480 , 7207200 , 8648640 , 10810800 , 14414400 , 17297280 , 21621600 , 32432400 , 36756720 , 43243200 , 61261200 , 73513440 , 110270160 , 122522400 , 147026880 , 183783600 , 245044800 , 294053760 , 367567200 , 551350800 , 698377680 , 735134400 , 1102701600 , 1396755360 , 2095133040 , 2205403200 , 2327925600 , 2793510720 , 3491888400 , 4655851200 , 5587021440 , 6983776800 , 10475665200 , 13967553600 , 20951330400 , 27935107200 , 41902660800 , 48886437600 , 64250746560 , 73329656400 , 80313433200 , 97772875200 , 128501493120 , 146659312800 , 160626866400 , 240940299600 , 293318625600 , 321253732800 , 481880599200 , 642507465600 , 963761198400 , 1124388064800 , 1606268664000 , 1686582097200 , 1927522396800 , 2248776129600 , 3212537328000 , 3373164194400 , 4497552259200 , 6746328388800 , 8995104518400 , 9316358251200 , 13492656777600 , 18632716502400 , 26985313555200 , 27949074753600 , 32607253879200 , 46581791256000 , 48910880818800 , 55898149507200 , 65214507758400 , 93163582512000 , 97821761637600 , 130429015516800 , 195643523275200 , 260858031033600 , 288807105787200 , 391287046550400 , 577614211574400 , 782574093100800 , 866421317361600 , 1010824870255200 , 1444035528936000 , 1516237305382800 , 1732842634723200 , 2021649740510400 , 2888071057872000 , 3032474610765600 , 4043299481020800 , 6064949221531200 , 8086598962041600 , 10108248702552000 , 12129898443062400 , 18194847664593600 , 20216497405104000 , 24259796886124800 , 30324746107656000 , 36389695329187200 , 48519593772249600 , 60649492215312000 , 72779390658374400 , 74801040398884800 , 106858629141264000 , 112201560598327200 , 149602080797769600 , 224403121196654400 , 299204161595539200 , 374005201994424000 , 448806242393308800 , 673209363589963200 , 748010403988848000 , 897612484786617600 , 1122015605983272000 , 1346418727179926400 , 1795224969573235200 , 2244031211966544000 , 2692837454359852800 , 3066842656354276800 , 4381203794791824000 , 4488062423933088000 , 6133685312708553600 , 8976124847866176000 , 9200527969062830400]
t = int(input())
for x in range(0, t):
a = int(input())
i = 0
for y in divisors:
if y > a:
print("win", numbers[i])
break
i = i+1
else:
print("lose")
``` | {
"language": "python",
"test_cases": [
{
"input": "3\n3\n5\n12345678\n",
"output": "win 6\nwin 12\nlose\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/IOPC2012/problems/IOPC1211"
} | vfc_3778 |
apps | verifiable_code | 1235 | Solve the following coding problem using the programming language python:
Given a number n. Find the last two digits of 5 ^ n ( 5 to the power of n ).
Remember that overflow can occur.
-----Input:-----
- N — the power in which you need to raise number 5.
-----Output:-----
Last two digits of 5^n.
-----Constraints-----
- $2 \leq N \leq 2.1018$
-----Sample Input:-----
2
-----Sample Output:-----
25
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
print(25)
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n",
"output": "25\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/CMR12121/problems/DGLST"
} | vfc_3782 |
apps | verifiable_code | 1236 | Solve the following coding problem using the programming language python:
You are given a set of n pens, each of them can be red, blue, green, orange, and violet in color. Count a minimum number of pens that should be taken out from the set so that any two neighboring pens have different colors. Pens are considered to be neighboring if there are no other pens between them.
-----Input:-----
-
The first line contains t denoting the number of test cases.
-
The first line of each test case will contain a single integer n.
-
The second line of each test case will contain a string s.
(s contains only 'R', 'B', 'G', 'O', and 'V' characters denoting red, blue, green, orange, and violet respectively)
-----Output:-----
For each test case, print single line containing one integer - The minimum number of pens that need to be taken out.
-----Constraints-----
- $1 \leq T \leq 100$
- $1 \leq n \leq 1000$
-----Sample Input:-----
2
5
RBBRG
5
RBGOV
-----Sample Output:-----
1
0
-----EXPLANATION:-----
In first test case, two blue pens are neighboring each other, if we take out any one of them then the string will be RBRG in which each pen has different neighbors.
In second test case, no pen needs to be taken out as each pen has different neighbors.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
t = int(input())
for _ in range(t):
n = int(input())
a = input().strip()
prev = a[0]
ans = -1
for i in a:
if prev == i:
ans += 1
prev = i
print(ans)
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n5\nRBBRG\n5\nRBGOV\n",
"output": "1\n0\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/CDGO2021/problems/DIFFPENS"
} | vfc_3786 |
apps | verifiable_code | 1237 | Solve the following coding problem using the programming language python:
You are standing near a very strange machine. If you put C cents in the machine, the remaining money in your purse will transform in an unusual way. If you have A dollars and B cents remaining in your purse after depositing the C cents, then after the transformation you will have B dollars and A cents. You can repeat this procedure as many times as you want unless you don't have enough money for the machine. If at any point C > B and A > 0, then the machine will allow you to break one of the A dollars into 100 cents so you can place C cents in the machine. The machine will not allow you to exchange a dollar for 100 cents if B >= C.
Of course, you want to do this to maximize your profit. For example if C=69 and you have 9 dollars and 77 cents then after you put 69 cents in the machine you will have 8 dollars and 9 cents (9.77 --> 9.08 --> 8.09). But I should warn you that you can't cheat. If you try to throw away 9 cents before the transformation (in order to obtain 99 dollars and 8 cents after), the machine will sense you are cheating and take away all of your money. You need to know how many times you should do this transformation in order to make a maximum profit. Since you are very busy man, you want to obtain the maximum possible profit in the minimum amount of time.
-----Input-----
The first line contains a single integer T <= 40, the number of test cases. T test cases follow. The only line of each test case contains three nonnegative integers A, B and C where A, B, C < 100. It means that you have A dollars and B cents in your purse and you need to put C cents in the machine to make the transformation.
-----Output-----
For each test case, output a single line containing the minimal number of times you should do this transformation in order to make a maximal profit. It is guaranteed that the answer is less than 10000.
-----Example-----
Input:
2
9 77 69
98 99 69
Output:
4
0
-----Explanation-----
In the first test we have the following sequence: 9.77, 8.09, 40.07, 38.39, 70.37, 68.69, 0.68. After last step we have not enough money for further transformations. The maximal profit will be after 4 transformations.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
# cook your dish here
for _ in range(int(input())):
a,b,c=list(map(int, input().split()))
p=a*100+b
mx=p
ans, cnt = 0, 0
while True:
cnt+=1
if p<c or cnt==10000:
break
else:
p-=c
a=p//100
b=p%100
p=b*100+a
if p>mx:
mx=p
ans=cnt
print(ans)
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n9 77 69\n98 99 69\n\n\n",
"output": "4\n0\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/MONTRANS"
} | vfc_3790 |
apps | verifiable_code | 1238 | Solve the following coding problem using the programming language python:
Chef likes to play with big numbers. Today, he has a big positive integer N. He can select any two digits from this number (the digits can be same but their positions should be different) and orders them in any one of the two possible ways. For each of these ways, he creates a two digit number from it (might contain leading zeros). Then, he will pick a character corresponding to the ASCII value equal to this number, i.e. the number 65 corresponds to 'A', 66 to 'B' and so on till 90 for 'Z'. Chef is only interested in finding which of the characters in the range 'A' to 'Z' can possibly be picked this way.
-----Input-----
The first line of the input contains an integer T denoting the number of test cases.
The first line of the input contains an integer N.
-----Output-----
For each test case, output a string containing characters Chef can pick in sorted order If the resulting size of string is zero, you should output a new line.
-----Constraints-----
- 1 ≤ T ≤ 10
- 1 ≤ N ≤ 10100000
-----Subtasks-----
- Subtask #1 (40 points) N ≤ 1010
- Subtask #2 (60 points) Original Constraints
-----Example-----
Input:
4
65
566
11
1623455078
Output:
A
AB
ACDFGHIJKLNPQRSTUVW
-----Explanation-----
Example case 1. Chef can pick digits 6 and 5 and create integers 56 and 65. The integer 65 corresponds to 'A'.
Example case 2. Chef can pick digits 6 and 5 and create 'A' as it equals 65. He can pick 6 and 6 (they are picked from position 2 and position 3, respectively) to create 'B' too. Hence answer is "AB".
Example case 3. It's not possible to create any character from 'A' to 'Z'. Hence, we just print a new line.
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 i in range(test):
N=input()
X=[]
list2=[]
for x in N:
X.append(x)
list1=[]
list1=list(set(X))
output=''
for x in list1:
for y in X:
if int(x)>=6:
n=int(x)*10+int(y)
list2.append(n)
for j in list1:
if int(j)>=6:
m=int(j)*10+int(j)
list2.remove(m)
list2.sort()
if len(list2)==0:
print(" ")
else:
list2.sort()
for k in list2:
if chr(k) not in output and 64<k<91:
output+=chr(k)
print(output)
``` | {
"language": "python",
"test_cases": [
{
"input": "4\n65\n566\n11\n1623455078\n",
"output": "A\nAB\nACDFGHIJKLNPQRSTUVW\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/CHEFPDIG"
} | vfc_3794 |
apps | verifiable_code | 1239 | Solve the following coding problem using the programming language python:
The chef is trying to solve some pattern problems, Chef wants your help to code it. Chef has one number K to form a new pattern. Help the chef to code this pattern problem.
-----Input:-----
- First-line will contain $T$, the number of test cases. Then the test cases follow.
- Each test case contains a single line of input, one integer $K$.
-----Output:-----
For each test case, output as the pattern.
-----Constraints-----
- $1 \leq T \leq 100$
- $1 \leq K \leq 100$
-----Sample Input:-----
2
2
4
-----Sample Output:-----
2
21
210
21
2
4
43
432
4321
43210
4321
432
43
4
-----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
t=int(input())
for _ in range(t):
n = int(input())
for i in range(n+1):
b = n
for space in range(n-i):
print(" ",end="")
for j in range(i+1):
print(b,end="")
b-=1
print()
for l in range(n):
a = n
for j1 in range(0,l+1):
print(" ",end="")
for k in range(n-l):
print(a,end="")
a-=1
print()
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n2\n4\n",
"output": "2\n21\n210\n21\n2\n4\n43\n432\n4321\n43210\n4321\n432\n43\n4\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/PBK32020/problems/ITGUY28"
} | vfc_3798 |
apps | verifiable_code | 1240 | Solve the following coding problem using the programming language python:
The chef is having one array of natural numbers. Cheffina challenges chef that find the sum of weights all the natural numbers present in the array, but the main problem is that all numbers have not original weights. After every 6 natural numbers weight is set to 1 as weight increases by 1 after that. (i.e. weight of 1 is 1, weight of 2 is 2 but the weight of 7 is 1 and weight of 8 is 2 and so on…). Help the chef to find the sum.
-----Input:-----
- First line will contain $T$, number of testcases. Then the testcases follow.
- Each testcase contains two lines of input, one integer $N$.
- Next line has N space separate natural numbers.
-----Output:-----
For each testcase, output in a single line answer.
-----Constraints-----
- $1 \leq T \leq 10$
- $1 \leq N \leq 10^5$
- $1 \leq arr[i] \leq 10^6$
-----Sample Input:-----
1
6
6 7 9 11 4 16
-----Sample Output:-----
23
-----EXPLANATION:-----
Array after conversion = [6, 1, 3, 5, 4, 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:
x = int(input())
arr = [int(i) for i in input().split()]
total = 0
for i in arr:
if i % 6 == 0:
total += 6
else:
total += (i % 6)
print(total)
t -= 1
``` | {
"language": "python",
"test_cases": [
{
"input": "1\n6\n6 7 9 11 4 16\n",
"output": "23\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/PEND2020/problems/ITGUY00"
} | vfc_3802 |
apps | verifiable_code | 1241 | Solve the following coding problem using the programming language python:
"Don't Drink and Drive, but when you do, Better Call Saul."
Once Jesse and Walter were fighting over extra cash, and Saul decided to settle it with a game of stone piles whose winner gets the extra money. The game is described as follows :
There are N$N$ piles of stones with A$A$1$1$,$,$ A$A$2$2$,$,$ ...$...$ A$A$N$N$ stones in each pile.
Jesse and Walter move alternately, and in one move, they remove one pile entirely.
After a total of X$X$ moves, if the Sum of all the remaining piles is odd, Walter wins the game and gets the extra cash, else Jesse is the winner.
Walter moves first.
Determine the winner of the game if both of them play optimally.
-----Input:-----
- The first line will contain T$T$, number of testcases. T$T$ testcases follow :
- The first line of each testcase contains two space-separated integers N,X$N, X$.
- The second line of each testcase contains N$N$ space-separated integers A$A$1$1$,$,$ A$A$2$2$,$,$ ...,$...,$A$A$N$N$.
-----Output:-----
For each test case, print a single line containing the string "Jesse" (without quotes), if Jesse wins the game or "Walter" (without quotes) if Walter wins.
-----Constraints-----
- 1≤T≤104$1 \leq T \leq 10^4$
- 2≤N≤105$2 \leq N \leq 10^5$
- 1≤X≤N−1$1 \leq X \leq N-1$
- 1≤A$1 \leq A$i$i$ ≤100$ \leq 100$
- The sum of N$N$ over all test cases does not exceed 106$10^6$
-----Sample Input:-----
2
5 3
4 4 4 3 4
7 4
3 3 1 1 1 2 4
-----Sample Output:-----
Jesse
Walter
-----EXPLANATION:-----
-
For Test Case 1 : Playing optimally, Walter removes 4. Jesse removes 3 and then Walter removes 4. Jesse wins as 4+4=8$4 + 4 = 8$ is even.
-
For Test Case 2 : Playing optimally, Walter removes 4, Jesse removes 3, Walter removes 2 and Jesse removes 1. Walter wins as 3+3+1=7$3 + 3 + 1 = 7$ is odd.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
n=int(input())
for i in range(n):
k,x=map(int,input().split())
l=list(map(int,input().split()))
f,e,o=0,0,0
for i in l:
if(i%2==0):
e+=1
else:
o+=1
if(o<=x//2):
f=1
elif(e<=x//2):
if((k-x)%2!=0):
f=0
else:
f=1
else:
if(x%2==0):
f=1
else:
f=0
if(f==1):
print('Jesse')
else:
print('Walter')
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n5 3\n4 4 4 3 4\n7 4\n3 3 1 1 1 2 4\n",
"output": "Jesse\nWalter\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/GMSTN"
} | vfc_3806 |
apps | verifiable_code | 1242 | Solve the following coding problem using the programming language python:
Chef loves to play with arrays by himself. Today, he has an array A consisting of N distinct integers. He wants to perform the following operation on his array A.
- Select a pair of adjacent integers and remove the larger one of these two. This decreases the array size by 1. Cost of this operation will be equal to the smaller of them.
Find out minimum sum of costs of operations needed to convert the array into a single element.
-----Input-----
First line of input contains a single integer T denoting the number of test cases. First line of each test case starts with an integer N denoting the size of the array A. Next line of input contains N space separated integers, where the ith integer denotes the value Ai.
-----Output-----
For each test case, print the minimum cost required for the transformation.
-----Constraints-----
- 1 ≤ T ≤ 10
- 2 ≤ N ≤ 50000
- 1 ≤ Ai ≤ 105
-----Subtasks-----
- Subtask 1 : 2 ≤ N ≤ 15 : 35 pts
- Subtask 2 : 2 ≤ N ≤ 100 : 25 pts
- Subtask 3 : 2 ≤ N ≤ 50000 : 40 pts
-----Example-----
Input
2
2
3 4
3
4 2 5
Output
3
4
-----Explanation-----Test 1 : Chef will make only 1 move: pick up both the elements (that is, 3 and 4), remove the larger one (4), incurring a cost equal to the smaller one (3).
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
from math import *
for t in range(int(input())):
n = int(input())
numberlist = list(map(int,input().split()))
numberlist.sort()
print(numberlist[0]* ( len(numberlist) -1))
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n2\n3 4\n3\n4 2 5\n",
"output": "3\n4\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/MNMX"
} | vfc_3810 |
apps | verifiable_code | 1243 | Solve the following coding problem using the programming language python:
Chef has a number N, Cheffina challenges the chef to check the divisibility of all the permutation of N by 5. If any of the permutations is divisible by 5 then print 1 else print 0.
-----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 1 or 0.
-----Constraints-----
- $1 \leq T \leq 10^6$
- $1 \leq N \leq 10^6$
-----Sample Input:-----
2
19
385
-----Sample Output:-----
0
1
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
a = int(input())
for i in range(a):
b = input()
if '5' in b or '0' in b:
print(1)
continue
print(0)
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n19\n385\n",
"output": "0\n1\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/PSTR2020/problems/ITGUY06"
} | vfc_3814 |
apps | verifiable_code | 1244 | Solve the following coding problem using the programming language python:
A Train started its journey at x=-infinity is travelling on the x-Coordinate Axis. Given n passengers and the coordinates $b_i$ and $d_i$ for each of the $ith$ passenger at which they board and leave from the train respectively. Due to current COVID-19 crisis, the train is monitored at each mile/coordinate. The infection degree of the train at each mile is equal to the total passengers present in the train at that mile/coordinate. The train stops its journey if no more passengers are there to board the train. The term infection severity of the journey is defined as the sum of infection degrees noted at each mile. Find the Infection severity of the journey. Note: A passenger is considered for calculation of infection degree at both boarding and leaving stations.
Since the answer can be very large, print it modulo $(10^9)+7$.
-----Input:-----
- First line will contain $N$, number of passengers. Then the $N$ lines follow.
- $i$th line contains two integers $b_i, d_i$ , the boarding and departure mile of $i$th passenger.
-----Output:-----
Print a single value, the Infection Severity of the journey modulo $(10^9)+7$.
-----Constraints-----
- $0 \leq N \leq 100000$
- $-500000 \leq b_i \leq 500000$
- $-500000 \leq d_i \leq 500000$
-----Sample Input:-----
3
0 2
1 3
-1 4
-----Sample Output:-----
12
-----EXPLANATION:-----
Infection degree at :
-1 is 1
0 is 2
1 is 3
2 is 3
3 is 2
4 is 1
Calculation started at mile -1 and ended at mile 4. Infection Severity = 1+2+3+3+2+1 =12
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
c=0
for i in range (int(input ())):
a, b=map(int, input().split())
c+=abs(a-b)+1
print(c%((10**9) +7))
``` | {
"language": "python",
"test_cases": [
{
"input": "3\n0 2\n1 3\n-1 4\n",
"output": "12\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/COW42020/problems/COW3C"
} | vfc_3818 |
apps | verifiable_code | 1245 | Solve the following coding problem using the programming language python:
The chef is trying to solve some pattern problems, Chef wants your help to code it. Chef has one number K to form a new pattern. Help the chef to code this pattern problem.
-----Input:-----
- First-line will contain $T$, the number of test cases. Then the test cases follow.
- Each test case contains a single line of input, one integer $K$.
-----Output:-----
For each test case, output as the pattern.
-----Constraints-----
- $1 \leq T \leq 100$
- $1 \leq K \leq 100$
-----Sample Input:-----
4
1
2
3
4
-----Sample Output:-----
1
13
57
135
7911
131517
1357
9111315
17192123
25272931
-----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
n = int(input())
l = [0] * n
for x in range(n):
l[x] = int(input())
for i in range(n):
z = 1
for j in range(1,l[i]+1):
for k in range(1,l[i]+1):
print(z,end='')
z += 2
print()
``` | {
"language": "python",
"test_cases": [
{
"input": "4\n1\n2\n3\n4\n",
"output": "1\n13\n57\n135\n7911\n131517\n1357\n9111315\n17192123\n25272931\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/PTRN2021/problems/ITGUY51"
} | vfc_3822 |
apps | verifiable_code | 1246 | Solve the following coding problem using the programming language python:
Walter White and Jesse Pinkman (a drug addict) both love to play with chemicals. One day they were playing with some chemicals to make an energy drink. Unknowingly they made a highly powerful drink. To test the drink on others also they called some of their friends and gave a drop of it to everyone. Now they all were feeling highly energetic and thought of an unique game to play with each other.
After pondering for a while, Jesse came up with an extraordinary idea of competing in a race around a circular globe with N checkpoints each of one unit. Walter and all their other friends agreed with it.They divided themselves in $2$ teams with $N$ teammates in each team.This race has two commencing points $A$ and $B$ strictly facing each other. Walter and his team commences from $A$ point and other team starts from $B$. Both the teams start running at the same time clockwise around the globe. Speed of every player is constant throughout the race. If a player has a speed $X$ then it means that he covers a distance of $X$ units in one second.The race ends when some member of one team overtakes all members of opposite team at any point of time. Now you have to tell if any team will win the race or not.They all are stubborn and can run forever just to win the race. Help them to know if it is possible in anyway that the race will come to an end.
For Clarity, you can visualize the path as a circular paths where $A$ and $B$ are opposite ends of diameter. It can be proven that the actual circumference of circle do not affect the answer.
It is also possible that someone don't run at all.Keep in mind that the fastest one wins the race so does the code.
-----Input:------
- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
- The first line of each test case contains a single integer $N$ number of teammates in both team.
- The second line contains $N$ space-separated integers $A_1, A_2 \ldots A_N$ denoting speed of A's Team
- The third line contains $N$ space-separated integers $B_1, B_2 \ldots B_N$ denoting speed of B's Team
-----Output:------
For each test case, print a single line denoting YES if the race ends at any point of time else NO
-----Constraints-----
- $1 \leq T \leq 10$
- $1 \leq N \leq 10^5$
- $0 \leq A_i \leq 2^{15}$
- $0 \leq B_i \leq 2^{15}$
-----Subtasks-----
Subtask #1 (30 points):
- $1 \le N \le 20$
- $0 \le A_i \le 11$
- $0 \le B_i \le 11$
Subtask #2 (70 points):
- Original constraints
-----Sample input:-----
1
5
1 2 3 4 5
2 7 8 9 9
-----Sample output-----
YES
-----Sample Explanation:------
Team B can overtake all members of Team A.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
# cook your dish here
l1=int(input())
for i in range(l1):
x=int(input())
y=list(map(int,input().split()))
z=list(map(int,input().split()))
if max(z)!=max(y):
print('YES')
else:
print('NO')
``` | {
"language": "python",
"test_cases": [
{
"input": "1\n5\n1 2 3 4 5\n2 7 8 9 9\n\n",
"output": "YES\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/CHPTRS01/problems/FUNRUN"
} | vfc_3826 |
apps | verifiable_code | 1247 | Solve the following coding problem using the programming language python:
Chef received a permutation $P_1, P_2, \ldots, P_N$ and also an integer $D$ from his good friend Grux, because Grux was afraid he would forget them somewhere. However, since Grux was just playing with the permutation, it was all shuffled, and Chef only likes sorted permutations, so he decided to sort it by performing some swaps.
Chef wants to use the integer $D$ he just received, so he is only willing to swap two elements of the permutation whenever their absolute difference is exactly $D$. He has limited time, so you should determine the minimum number of swaps he needs to perform to sort the permutation, or tell him that it is impossible to sort it his way.
-----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 $P_1, P_2, \ldots, P_N$.
-----Output-----
For each test case, print a single line containing one integer ― the minimum number of swaps, or $-1$ if it is impossible to sort the permutation.
-----Constraints-----
- $1 \le T \le 20$
- $1 \le N \le 200,000$
- $1 \le D \le N$
- $1 \le P_i \le N$ for each valid $i$
- $P_1, P_2, \ldots, P_N$ are pairwise distinct
- the sum of $N$ over all test cases does not exceed $10^6$
-----Subtasks-----
Subtask #1 (20 points): $D = 1$
Subtask #2 (30 points):
- $N \le 1,000$
- the sum of $N$ over all test cases does not exceed $10,000$
Subtask #3 (50 points): original constraints
-----Example Input-----
2
5 2
3 4 5 2 1
5 2
4 3 2 1 5
-----Example Output-----
3
-1
-----Explanation-----
Example case 1: Chef can perform the following swaps in this order:
- swap the first and fifth element
- swap the third and fifth element
- swap the second and fourth element
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
import sys
sys.setrecursionlimit(10000000)
def mergeSortInversions(arr):
if len(arr) == 1:
return arr, 0
larr=len(arr)
a = arr[:larr//2]
b = arr[larr//2:]
a, ai = mergeSortInversions(a)
b, bi = mergeSortInversions(b)
c = []
i = 0
j = 0
inversions = 0 + ai + bi
la=len(a)
while i < la and j < len(b):
if a[i] <= b[j]:
c.append(a[i])
i += 1
else:
c.append(b[j])
j += 1
inversions += (la-i)
c += a[i:]
c += b[j:]
return c, inversions
for _ in range(int(input())):
n,d=list(map(int,input().split()))
p=[int(o) for o in input().split()]
array=[[] for i in range(d)]
flag=0
for i in range(n):
array[i%d].append(p[i])
if p[i]%((i%d)+1)!=0:
flag=1
ans=0
dumarr=[0]*n
for i in range(d):
array[i],v=mergeSortInversions(array[i])
for j in range(len(array[i])):
dumarr[i+j*d]=array[i][j]
ans+=v
p=sorted(p)
# print(dumarr)
if dumarr==p:
print(ans)
else:
print(-1)
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n5 2\n3 4 5 2 1\n5 2\n4 3 2 1 5\n",
"output": "3\n-1\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/DPERM"
} | vfc_3830 |
apps | verifiable_code | 1248 | Solve the following coding problem using the programming language python:
Chef has recently learned about number bases and is becoming fascinated.
Chef learned that for bases greater than ten, new digit symbols need to be introduced, and that the convention is to use the first few letters of the English alphabet. For example, in base 16, the digits are 0123456789ABCDEF. Chef thought that this is unsustainable; the English alphabet only has 26 letters, so this scheme can only work up to base 36. But this is no problem for Chef, because Chef is very creative and can just invent new digit symbols when she needs them. (Chef is very creative.)
Chef also noticed that in base two, all positive integers start with the digit 1! However, this is the only base where this is true. So naturally, Chef wonders: Given some integer N, how many bases b are there such that the base-b representation of N starts with a 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.
Each test case consists of one line containing a single integer N (in base ten).
-----Output-----
For each test case, output a single line containing the number of bases b, or INFINITY if there are an infinite number of them.
-----Constraints-----
-----Subtasks-----Subtask #1 (16 points):
- 1 ≤ T ≤ 103
- 0 ≤ N < 103
Subtask #2 (24 points):
- 1 ≤ T ≤ 103
- 0 ≤ N < 106
Subtask #3 (28 points):
- 1 ≤ T ≤ 103
- 0 ≤ N < 1012
Subtask #4 (32 points):
- 1 ≤ T ≤ 105
- 0 ≤ N < 1012
-----Example-----
Input:4
6
9
11
24
Output:4
7
8
14
-----Explanation-----
In the first test case, 6 has a leading digit 1 in bases 2, 4, 5 and 6: 610 = 1102 = 124 = 115 = 106.
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 finder(n):
cnt=0
for i in range(2,n+1):
a=n
while a!=0:
r=a%i
a=a//i
if r==1:
cnt+=1
return cnt
t=int(input())
for _ in range(t):
n=int(input())
if n==0:
print(0)
elif n==1:
print('INFINITY')
else:
print(finder(n))
``` | {
"language": "python",
"test_cases": [
{
"input": "4\n6\n9\n11\n24\n",
"output": "4\n7\n8\n14\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/BASE"
} | vfc_3834 |
apps | verifiable_code | 1249 | Solve the following coding problem using the programming language python:
For a permutation P = (p1, p2, ..., pN) of numbers [1, 2, ..., N], we define the function f(P) = max(p1, p2) + max(p2, p3) + ... + max(pN-1, pN).
You are given N and an integer K. Find and report a permutation P of [1, 2, ..., N] such that f(P) = K, if such a permutation exists.
Note f([1]) = 0.
-----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 consists of two space-separated integers N, K respectively.
-----Output-----
For each test case, if a permutation satisfying the condition exists, output a single line containing N space-separated integers which denotes any such permutation. If no such permutation exists, output a single integer -1 instead.
Use fast I/O methods since the size of the output is large.
-----Constraints-----
- 1 ≤ T ≤ 40
- 1 ≤ N ≤ 105
- Sum of N over all test cases in each file ≤ 106
- 0 ≤ K ≤ 2 * 1010
-----Example-----
Input:
3
4 12
2 2
5 14
Output:
-1
1 2
5 4 3 2 1
-----Explanation-----
Example 1. There doesn't exist any permutation of numbers [1, 2, 3, 4] that can have its f value equal to 4. Hence answer is -1.
Example 2. The permutations [1, 2] and [2, 1] both have their f values equal to 2. You can print any of these two permutations.
Example 3. The permutation [5, 4, 3, 2, 1]
has f value = max(5, 4) + max(4, 3) + max(3, 2) + max(2, 1) = 5 + 4 + 3 + 2 = 14.
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,k=[int(i) for i in input().split()]
if(n%2==0):
if(k<(n*(n+1))//2 - 1 or k>3*((n//2)**2) - 1):print(-1)
elif(k==(n*(n+1))//2 - 1):
for i in range(1,n+1):print(i,'',end='')
print()
else:
k,count,p,l,x = k-(n*(n+1))//2 + 1,0,0,[0 for i in range(n)],1
while(k>0):p+=2 ;k,count = k-n+p ,count+1
for i in range(n,n-count+1,-1):l[x]=i ;x+=2
k=-k ;l[2*count - 1 +k],p = n-count+1 ,1
for i in range(n):
if(l[i]==0):l[i]=p ; p+=1
for i in l:print(i,'',end='')
print()
else:
if(n==1):print(1) if(k==0) else print(-1)
elif(k<(n*(n+1))//2 - 1 or k>3*(n//2)*(n//2 + 1)):print(-1)
elif(k==(n*(n+1))//2 - 1):
for i in range(1,n+1):print(i,'',end='')
print()
else:
k,count,p,l,x = k-(n*(n+1))//2 + 1,0,0,[0 for i in range(n)],1
while(k>0): p+=2 ; k,count = k-n+p ,count+1
``` | {
"language": "python",
"test_cases": [
{
"input": "3\n4 12\n2 2\n5 14\n",
"output": "-1\n1 2\n5 4 3 2 1\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/GENPERM"
} | vfc_3838 |
apps | verifiable_code | 1250 | Solve the following coding problem using the programming language python:
Our chef has been assigned a task to make a necklace of length N, from gold, diamond and platinum.There is single kind of gold, two types of diamond and three types of platinum available.
A necklace can be represented as strings of the form (G)∗(D1|D2)∗(P1|P2|P3)∗$ (G)*(D1|D2)*(P1|P2|P3)* $ where (x|y) means we can use x or y and ∗$ * $ means we can repeat the previous parenthesized expression 0 or more times.
Instead of making necklace he choose to count all such distinct necklaces possible for a given length N.
-----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.
-Only line of every test case contains an integer N$N$ denoting the length of the necklace required.
-----Output:-----
For each test case, print the number of all such distinct necklaces, with given length. As the number can be really large, print it modulo 109+7$10^{9}+7$.
-----Constraints-----
- 1≤T≤10000$1 \leq T \leq 10000$
- 2≤N≤1000000000$2 \leq N \leq 1000000000$
- String S$S$ consists of only upper case english alphabets.
-----Subtasks-----
- 20 points : 1≤N≤5$1 \leq N \leq 5$
- 70 points : Original$Original$ Constraints$Constraints$
-----Sample Input:-----
2
1
2
-----Sample Output:-----
6
25
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
t=int(input())
for _ in range(t):
n=int(input())
p=10**9+7
a=(pow(3,n+1,p)-1)
b=(pow(2,n+1,p)-1)
print((((3*a)//2)%p-(2*(b))%p+p)%p)
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n1\n2\n",
"output": "6\n25\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/ALQU2018/problems/GDP"
} | vfc_3842 |
apps | verifiable_code | 1251 | Solve the following coding problem using the programming language python:
Chef likes to travel very much. He plans some travel routes and wants to know their lengths. He hired you to make these calculations. But be careful, some of the routes are incorrect. There may be some misspelling in city names or there will be no road between some two consecutive cities in the route. Also note that Chef hates to visit the same city twice during his travel. Even the last city should differ from the first. Two consecutive cities in the route should also be different. So you need to check these conditions for the given routes too.
You will be given the list of all cities and all roads between them with their lengths. All roads are one-way. Also you will be given the list of all travel routes that Chef plans. For each route you should check whether it is correct and find its length in this case.
-----Input-----
The first line contains positive integer N, the number of cities. The second line contains space separated list of N strings, city names. All city names are distinct.
The third line contains non-negative integer M, the number of available roads. Each of the next M lines describes one road and contains names C1 and C2 of two cities followed by the positive integer D, the length of the one-way road that connects C1 with C2. It is guaranteed that C1 and C2 will be correct names of two different cities from the list of N cities given in the second line of the input file. For each pair of different cities there is at most one road in each direction and each road will be described exactly once in the input file.
Next line contains positive integer T, the number of travel routes planned by the Chef. Each of the next T lines contains positive integer K followed by K strings, names of cities of the current route. Cities are given in order in which Chef will visit them during his travel.
All strings in the input file composed only of lowercase, uppercase letters of the English alphabet and hyphens. Each string is non-empty and has length at most 20. If some line of the input file contains more then one element than consecutive elements of this line are separated by exactly one space. Each line of the input file has no leading or trailing spaces.
-----Output-----
For each travel route from the input file output a single line containing word ERROR if the route is incorrect and its length otherwise.
-----Constraints-----
1 <= N <= 50
0 <= M <= N * (N - 1)
1 <= D <= 20000
1 <= T <= 50
1 <= K <= 50
1 <= length of each string <= 20
-----Example-----
Input:
5
Donetsk Kiev New-York Miami Hollywood
9
Donetsk Kiev 560
Kiev New-York 7507
New-York Miami 1764
Miami Hollywood 28
Hollywood Miami 30
Miami New-York 1764
Kiev Donetsk 550
Hollywood New-York 1736
New-York Hollywood 1738
13
5 Donetsk Kiev New-York Miami Hollywood
5 Hollywood Miami New-York Kiev Donetsk
3 Donetsk Kiev Donetsk
2 Kyiv New-York
3 New-York Hollywood Miami
2 New-York Miami
3 Hollywood New-York Miami
4 Donetsk Kiev Miami Hollywood
2 Donetsk Hollywood
1 Donetsk
2 Mumbai Deli
6 Donetsk Kiev New-York Miami Hollywood New-York
2 Miami Miami
Output:
9859
ERROR
ERROR
ERROR
1768
1764
3500
ERROR
ERROR
0
ERROR
ERROR
ERROR
-----Explanation-----
The 2nd route is incorrect since there is no road from New-York to Kiev. Note however that inverse road from Kiev to New-York exists.
The 3rd route is incorrect since the first city coincides with the last one.
The 4th route is incorrect since there is no city with name Kyiv (Probably Chef means Kiev but he misspells this word).
The 8th route is incorrect since there is no road from Miami to Kiev.
The 9th route is incorrect since there is no road from Donetsk to Hollywood.
The 10th route is correct. Note that a route composed of exactly one city is always correct provided that city name is written correctly.
The 11th route is incorrect since there is no cities with names Mumbai and Deli. (Probably Chef is not so good in geography :))
The 12th route is incorrect since city New-York is visited twice.
Finally the 13th route is incorrect since we have equal consecutive cities.
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 _r(*conv) :
r = [conv[i](x) for i, x in enumerate(input().strip().split(' '))]
return r[0] if len(r) == 1 else r
def _ra(conv) :
return list(map(conv, input().strip().split(' ')))
def _rl() :
return list(input().strip())
def _rs() :
return input().strip()
def _a(k, *v) :
return all(x == k for x in v)
def _i(conv) :
for line in sys.stdin :
yield conv(line)
##################################################################
n = _r(int)
lookup = dict([(x, i) for i, x in enumerate(_ra(str))])
g = [(set(), dict()) for _ in range(n)]
m = _r(int)
for _ in range(m) :
c1, c2, d = _r(str, str, int)
i1 = lookup[c1]
g[i1][0].add(c2)
g[i1][1][c2] = d
t = _r(int)
for _ in range(t) :
k = _ra(str)[1:]
failed = False
if len(set(k)) != len(k) :
failed = True
if not failed :
if k[0] not in lookup :
failed = True
else :
r = 0
v = g[lookup[k[0]]]
for i in range(1, len(k)) :
if k[i] not in v[0] :
failed = True
break
r += v[1][k[i]]
v = g[lookup[k[i]]]
if not failed :
print(r)
if failed :
print('ERROR')
``` | {
"language": "python",
"test_cases": [
{
"input": "5\nDonetsk Kiev New-York Miami Hollywood\n9\nDonetsk Kiev 560\nKiev New-York 7507\nNew-York Miami 1764\nMiami Hollywood 28\nHollywood Miami 30\nMiami New-York 1764\nKiev Donetsk 550\nHollywood New-York 1736\nNew-York Hollywood 1738\n13\n5 Donetsk Kiev New-York Miami Hollywood\n5 Hollywood Miami New-York Kiev Donetsk\n3 Donetsk Kiev Donetsk\n2 Kyiv New-York\n3 New-York Hollywood Miami\n2 New-York Miami\n3 Hollywood New-York Miami\n4 Donetsk Kiev Miami Hollywood\n2 Donetsk Hollywood\n1 Donetsk\n2 Mumbai Deli\n6 Donetsk Kiev New-York Miami Hollywood New-York\n2 Miami Miami\n",
"output": "9859\nERROR\nERROR\nERROR\n1768\n1764\n3500\nERROR\nERROR\n0\nERROR\nERROR\nERROR\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/TRAVELER"
} | vfc_3846 |
apps | verifiable_code | 1252 | Solve the following coding problem using the programming language python:
Given a number $n$, give the last digit of sum of all the prime numbers from 1 to $n$ inclusive.
-----Input:-----
- First line contains number of testcase $t$.
- Each testcase contains of a single line of input, number $n$.
-----Output:-----
Last digit of sum of every prime number till n.
-----Constraints-----
- $1 \leq T \leq 10$
- $2 \leq N \leq 10^6$
-----Sample Input:-----
1
10
-----Sample Output:-----
7
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
# cook your dish here
import math
N = 10**6
sum_arr = [0] * (N + 1)
def lprime():
arr = [0] * (N + 1)
arr[0] = 1
arr[1] = 1
for i in range(2, math.ceil(math.sqrt(N) + 1)):
if arr[i] == 0:
for j in range(i * i, N + 1, i):
arr[j] = 1
curr_prime_sum = 0
for i in range(1, N + 1):
if arr[i] == 0:
curr_prime_sum += i
sum_arr[i] = curr_prime_sum
n=int(input())
lprime()
for _ in range(n):
x=int(input())
print(sum_arr[x]%10)
``` | {
"language": "python",
"test_cases": [
{
"input": "1\n10\n",
"output": "7\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/CSEP2020/problems/IRVS"
} | vfc_3850 |
apps | verifiable_code | 1253 | Solve the following coding problem using the programming language python:
People in Karunanagar are infected with Coronavirus. To understand the spread of disease and help contain it as early as possible, Chef wants to analyze the situation in the town. Therefore, he does the following:
- Chef represents the population of Karunanagar as a binary string of length $N$ standing in a line numbered from $1$ to $N$ from left to right, where an infected person is represented as $1$ and an uninfected person as $0$.
- Every day, an infected person in this binary string can infect an adjacent (the immediate left and right) uninfected person.
- Therefore, if before Day 1, the population is $00100$, then at the end of Day 1, it becomes $01110$ and at the end of Day 2, it becomes $11111$.
But people of Karunanagar are smart and they know that if they 'socially isolate' themselves as early as possible, they reduce the chances of the virus spreading. Therefore on $i$-th day, person numbered $P_i$ isolates himself from person numbered $P_i - 1$, thus cannot affect each other. This continues in the town for $D$ days.
Given the population binary string before Day 1, Chef wants to calculate the total number of infected people in Karunanagar at the end of the day $D$. Since Chef has gone to wash his hands now, can you help do the calculation for him?
-----Input:-----
- First line will contain $T$, number of testcases. Then the test cases follow.
- The first line of each test case contains a single integer $N$ denoting the length of the binary string.
- The next line contains a binary string of length $N$ denoting the population before the first day, with $1$ for an infected person and $0$ for uninfected.
- The next line contains a single integer $D$ - the number of days people isolate themselves.
- The next line contains $P$ - a list of $D$ distinct space-separated integers where each $P_{i}$ denotes that at the start of $i^{th}$ day, person $P_{i}$ isolated him/herself from the person numbered $P_i-1$.
-----Output:-----
For each test case, print a single integer denoting the total number of people who are infected after the end of $D^{th}$ day.
-----Constraints-----
- $1 \leq T \leq 200$
- $2 \leq N \leq 10^{4}$
- $1 \leq D < N$
- $2 \leq P_{i} \leq N$ for $1 \le i \le D$
-----Subtasks-----
Subtask #1(30 points): $1 \leq T \leq 100$, $2 \leq N \leq 2000$
Subtask #2(70 points): Original Constraints
-----Sample Input:-----
2
9
000010000
3
2 5 8
5
00001
1
5
-----Sample Output:-----
6
1
-----EXPLANATION:-----
For the purpose of this explanation, a social distance can be denoted with a '$|$'.
For the first testcase:
-
Before Day $1$, the population is: $0|00010000$
-
Before Day $2$, the population is: $0|001|11000$
-
Before Day $3$, the population is: $0|011|111|00$
-
Therefore, after Day $3$, the population will be: $0|111|111|00$
So, there are $6$ infected persons.
For the second testcase:
Before Day $1$, the population is: $0000|1$
Therefore, there is one infected person.
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,data,D,People = int(input()),list(map(int,list(input()))),int(input()),list(map(int,input().split()))
data.insert(0,"|"),data.append("|")
infected = []
for i in range(1,N+1):
if(data[i]==1):
infected.append(i)
i = 0
while(i<D):
boundary = People[i] + i
data.insert(boundary,"|")
times = len(infected)
for p in range(times):
index = infected[p]
if(index>=boundary):
index+=1
infected[p]+=1
if(data[index]==1):
if(data[index+1]==0):
data[index+1] = 1
infected.append(index+1)
if(data[index-1]==0):
data[index-1] = 1
infected.append(index-1)
else:
infected.remove(index)
times-=1
i+=1
infected.sort()
print(data.count(1))
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n9\n000010000\n3\n2 5 8\n5\n00001\n1\n5\n",
"output": "6\n1\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/CHPTRS01/problems/WASHHAND"
} | vfc_3854 |
apps | verifiable_code | 1254 | Solve the following coding problem using the programming language python:
Chef wants to organize a contest. Predicting difficulty levels of the problems can be a daunting task. Chef wants his contests to be balanced in terms of difficulty levels of the problems.
Assume a contest had total P participants. A problem that was solved by at least half of the participants (i.e. P / 2 (integer division)) is said to be cakewalk difficulty. A problem solved by at max P / 10 (integer division) participants is categorized to be a hard difficulty.
Chef wants the contest to be balanced. According to him, a balanced contest must have exactly 1 cakewalk and exactly 2 hard problems. You are given the description of N problems and the number of participants solving those problems. Can you tell whether the contest was balanced or not?
-----Input-----
The first line of the input contains an integer T denoting the number of test cases.
The first line of each test case contains two space separated integers, N, P denoting the number of problems, number of participants respectively.
The second line contains N space separated integers, i-th of which denotes number of participants solving the i-th problem.
-----Output-----
For each test case, output "yes" or "no" (without quotes) denoting whether the contest is balanced or not.
-----Constraints-----
- 1 ≤ T, N ≤ 500
- 1 ≤ P ≤ 108
- 1 ≤ Number of participants solving a problem ≤ P
-----Subtasks-----
- Subtask #1 (40 points): P is a multiple of 10
- Subtask #2 (60 points): Original constraints
-----Example-----
Input
6
3 100
10 1 100
3 100
11 1 100
3 100
10 1 10
3 100
10 1 50
4 100
50 50 50 50
4 100
1 1 1 1
Output
yes
no
no
yes
no
no
-----Explanation-----
Example case 1.: The problems are of hard, hard and cakewalk difficulty. There is 1 cakewalk and 2 hard problems, so the contest is balanced.
Example case 2.: The second problem is hard and the third is cakewalk. There is 1 cakewalk and 1 hard problem, so the contest is not balanced.
Example case 3.: All the three problems are hard. So the contest is not balanced.
Example case 4.: The problems are of hard, hard, cakewalk difficulty. The contest is balanced.
Example case 5.: All the problems are cakewalk. The contest is not balanced.
Example case 6.: All the problems are hard. The contest is not balanced.
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 z in range(t) :
n,p = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
c = [x for x in a if x >= p//2]
h = [x for x in a if x <= p//10]
if len(c)==1 and len(h)==2 :
print("yes")
else:
print("no")
``` | {
"language": "python",
"test_cases": [
{
"input": "6\n3 100\n10 1 100\n3 100\n11 1 100\n3 100\n10 1 10\n3 100\n10 1 50\n4 100\n50 50 50 50\n4 100\n1 1 1 1\n",
"output": "yes\nno\nno\nyes\nno\nno\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/PERFCONT"
} | vfc_3858 |
apps | verifiable_code | 1255 | Solve the following coding problem using the programming language python:
You are teaching students to generate strings consisting of unique lowercase latin characters (a-z). You give an example reference string $s$ to the students.
You notice that your students just copy paste the reference string instead of creating their own string. So, you tweak the requirements for strings submitted by the students.
Let us define a function F(s, t) where s and t are strings as the number of characters that are same in both the strings. Note that the position doesn't matter. Here are a few examples of F(s, t):
F("abc", "def") = 0
F("abc", "acb") = 3
F("back", "abcd") = 3
Now you ask your students to output a string t with lowercase unique characters of the same length as $s$, such that F(s, t) $\leq k$ where you are also given the value of $k$. If there are multiple such strings, you ask them to output the lexicographically smallest possible string. If no such string is possible, output the string "NOPE" without quotes.
-----Input:-----
- The first line will contain $T$, the number of testcases. Then the testcases follow.
- Each testcase contains of a single line of input, which contains a string $s$ and an integer $k$.
-----Output:-----
For each testcase, output in a single line the lexicographically smallest string t such that F(s, t) <= k or "NOPE" without quotes if no such string exists.
-----Constraints-----
- $1 \leq T \leq 10000$
- $1 \leq $length of string s $(|s|) \leq 26$
- $s$ only consists of characters $a$ to $z$
- There are no repeating characters in s
- $0 \leq k \leq |s|$
-----Sample Input:-----
4
helowrd 0
background 0
abcdefghijklmnopqrstuvwxyz 0
b 1
-----Sample Output:-----
abcfgij
efhijlmpqs
NOPE
a
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
for _ in range(int(input())):
s,k=map(str,input().split())
k=int(k)
n="NOPE"
al=[0]*26
for ele in s:
al[ord(ele)-ord('a')]=1
l=len(s)
ans=[]
# print(al)
for i in range(26):
if len(ans)==l:
break
elif al[i]==1 and k>0:
k-=1
ans.append(chr(i+ord('a')))
elif al[i]==0:
ans.append(chr(i+ord('a')))
if len(ans)!=l:
print(n)
else:
print("".join(ans))
``` | {
"language": "python",
"test_cases": [
{
"input": "4\nhelowrd 0\nbackground 0\nabcdefghijklmnopqrstuvwxyz 0\nb 1\n",
"output": "abcfgij\nefhijlmpqs\nNOPE\na\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/SDIFFSTR"
} | vfc_3862 |
apps | verifiable_code | 1256 | Solve the following coding problem using the programming language python:
Little chef has just been introduced to the world of numbers! While experimenting with addition and multiplication operations, the little chef came up with the following problem:
Given an array A of non-negative integers, how many pairs of indices i and j exist such that A[i]*A[j] > A[i]+A[j] where i < j .
Now being a learner, little chef isn't able to solve this problem efficiently and hence turns to you for help.
-----Input-----
First line of input contains an integer T denoting the number of test cases. For each test case, the first line contains an integer N denoting the number of integers in the array. The next line contains N space separated integers where the ith integer represents A[i].
Note : There may be trailing spaces on each line of input.
-----Output-----
For each test, print the required number of pairs in a single line.
-----Constraints-----
- 1 ≤ T ≤ 10
- 2 ≤ N ≤ 100000 (105)
- 0 ≤ A[i] ≤ 1000000 (106)
-----Example-----
Input:
2
3
3 4 5
4
1 1 1 1
Output:
3
0
-----Explanation-----
Example case 1.
All pairs of numbers satisfy the criteria. Total number of pairs equals 3.
Example case 2.
No pair of numbers satisfy the criteria.
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())
res = []
for i in range(t):
n = int(input())
arr = [int(i) for i in input().split()]
num_2 = 0
num = 0
for j in range(len(arr)):
if arr[j] == 2:
num_2 += 1
if arr[j] > 2:
num += 1
res.append(num_2 * num + (num * (num - 1)) // 2)
for z in res:
print(z)
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n3\n3 4 5\n4\n1 1 1 1\n",
"output": "3\n0\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/PROSUM"
} | vfc_3866 |
apps | verifiable_code | 1257 | Solve the following coding problem using the programming language python:
The chef was chatting with his friend who was a mathematician.
Chef said "Hi !".
His friend replied that '!' is the symbol of factorial.
Chef had never heard about it and he asked more about it. Then his friend taught him how to calculate the factorial of a number.
Chef loved that But as always he got tired after calculating a few values and asked you to do it for him.
-----Input-----
N : Number of inputs
then N lines with input T
N<10
T<=200
-----Output-----
The result for the corresponding value of T
-----Example-----
Input:
3
5
4
6
Output:
120
24
720
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
factorials=[1]
for x in range(1,201):
factorials.append(factorials[x-1]*x)
x=int(input())
for x in range(x):
n=int(input())
print(factorials[n])
``` | {
"language": "python",
"test_cases": [
{
"input": "3\n5\n4\n6\n",
"output": "120\n24\n720\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/AGTK2012/problems/ALGFACT"
} | vfc_3870 |
apps | verifiable_code | 1258 | Solve the following coding problem using the programming language python:
Chef Zidane likes the number 9. He has a number N, and he wants to turn it into a multiple of 9. He cannot add or remove digits, and he can only change one digit at a time. The only allowed operation is to increment or decrement a digit by one, and doing this takes exactly one second. Note that he cannot increase a digit 9 or decrease a digit 0, and the resulting number must not contain any leading zeroes unless N has a single digit.
Chef Zidane wants to know the minimum amount of time (in seconds) needed to accomplish this. Please help him, before his kitchen gets overwhelmed with mist!
-----Input-----
The first line of the input contains an integer T denoting the number of test cases. The description of T test cases follows.
Each test case consists of one line containing a single positive integer N.
-----Output-----
For each test case, output a single line containing the answer.
-----Constraints-----
- 1 ≤ T ≤ 105
- 1 ≤ N ≤ 10105
- N will not contain leading zeroes.
- Each test file is at most 3Mb in size.
-----Example-----
Input:4
1989
86236
90210
99999999999999999999999999999999999999988
Output:0
2
3
2
-----Explanation-----
Example case 1. 1989 is already divisible by 9, so no operations are needed to be performed.
Example case 2. 86236 can be turned into a multiple of 9 by incrementing the first and third digit (from the left), to get 96336. This takes 2 seconds.
Example case 3. 90210 can be turned into a multiple of 9 by decrementing the third digit twice and the fourth digit once, to get 90000. This takes 3 seconds.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
s=int(input())
while(s>0):
s-=1
a=input()
c=0
for x in a:
c+=int(x)
if(c<9 and len(a)!=1):
print(9-c%9)
else:
print(min(9-c%9,c%9))
``` | {
"language": "python",
"test_cases": [
{
"input": "4\n1989\n86236\n90210\n99999999999999999999999999999999999999988\n",
"output": "0\n2\n3\n2\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/DIVNINE"
} | vfc_3874 |
apps | verifiable_code | 1259 | Solve the following coding problem using the programming language python:
Vasya likes the number $239$. Therefore, he considers a number pretty if its last digit is $2$, $3$ or $9$.
Vasya wants to watch the numbers between $L$ and $R$ (both inclusive), so he asked you to determine how many pretty numbers are in this range. Can you help him?
-----Input-----
- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
- The first and only line of each test case contains two space-separated integers $L$ and $R$.
-----Output-----
For each test case, print a single line containing one integer — the number of pretty numbers between $L$ and $R$.
-----Constraints-----
- $1 \le T \le 100$
- $1 \le L \le R \le 10^5$
-----Subtasks-----
Subtask #1 (100 points): original constraints
-----Example Input-----
2
1 10
11 33
-----Example Output-----
3
8
-----Explanation-----
Example case 1: The pretty numbers between $1$ and $10$ are $2$, $3$ and $9$.
Example case 2: The pretty numbers between $11$ and $33$ are $12$, $13$, $19$, $22$, $23$, $29$, $32$ and $33$.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
# cook your dish here
t=int(input())
for _ in range(t):
n,m = map(int,input().split())
count=0
for i in range(n,m+1):
p=str(i)
if p[-1]=='2' or p[-1]=='3' or p[-1]=='9':
count+=1
print(count)
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n1 10\n11 33\n",
"output": "3\n8\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/problems/NUM239"
} | vfc_3878 |
apps | verifiable_code | 1260 | Solve the following coding problem using the programming language python:
Lavanya and Nikhil have K months of holidays ahead of them, and they want to go on exactly K road trips, one a month. They have a map of the various cities in the world with the roads that connect them. There are N cities, numbered from 1 to N. We say that you can reach city B from city A if there is a sequence of roads that starts from city A and ends at city B. Note that the roads are bidirectional. Hence, if you can reach city B from city A, you can also reach city A from city B.
Lavanya first decides which city to start from. In the first month, they will start from that city, and they will visit every city that they can reach by road from that particular city, even if it means that they have to pass through cities that they have already visited previously. Then, at the beginning of the second month, Nikhil picks a city that they haven't visited till then. In the second month, they first fly to that city and visit all the cities that they can reach from that city by road. Then, in the third month, Lavanya identifies a city, and they fly there and visit all cities reachable from there by road. Then in the fourth month it is Nikhil's turn to choose an unvisited city to start a road trip, and they alternate like this. Note that the city that they fly to (that is, the city from where they start each month's road trip) is also considered as being visited.
Each city has some museums, and when they visit a city for the first time, Lavanya makes them visit each of the museums there. Lavanya loves going to museums, but Nikhil hates them. Lavanya always makes her decisions so that they visit the maximum number of museums possible that month, while Nikhil picks cities so that the number of museums visited that month is minimized.
Given a map of the roads, the number of museums in each city, and the number K, find the total number of museums that they will end up visiting at the end of K months. Print -1 if they will have visited all the cities before the beginning of the Kth month, and hence they will be left bored at home for some of the K months.
-----Input-----
- The first line contains a single integer, T, which is the number of testcases. The description of each testcase follows.
- The first line of each testcase contains three integers: N, M and K, which represents the number of cities, number of roads and the number of months.
- The ith of the next M lines contains two integers, ui and vi. This denotes that there is a direct road between city ui and city vi.
- The next line contains N integers, the ith of which represents the number of museums in city i.
-----Output-----
For each test case, if they can go on K road trips, output a single line containing a single integer which should be the total number of museums they visit in the K months. Output -1 if they can't go on K road trips.
-----Constraints-----
- 1 ≤ T ≤ 3
- 1 ≤ N ≤ 106
- 0 ≤ M ≤ 106
- 1 ≤ K ≤ 106
- 1 ≤ ui, vi ≤ N
- There is no road which goes from one city to itself. ie. ui ≠ vi.
- There is at most one direct road between a pair of cities.
- 0 ≤ Number of museums in each city ≤ 1000
- Sum of N over all testcases in a file will be ≤ 1.5 * 106
-----Subtasks-----
- Subtask 1 (11 points): M = 0
- Subtask 2 (21 points): Each city has at most two roads of which it is an end point. That is, for every i, there are at most two roads (u, v) in the input, such that u = i or v = i.
- Subtask 3 (68 points): Original constraints.
-----Example-----
Input:
3
10 10 3
1 3
3 5
5 1
1 6
6 2
5 6
2 5
7 10
4 7
10 9
20 0 15 20 25 30 30 150 35 20
10 10 2
1 3
3 5
5 1
1 6
6 2
5 6
2 5
7 10
4 7
10 9
20 0 15 20 25 30 30 150 35 20
10 10 5
1 3
3 5
5 1
1 6
6 2
5 6
2 5
7 10
4 7
10 9
20 0 15 20 25 30 30 150 35 20
Output:
345
240
-1
-----Explanation-----
Notice that in all the three testcases, everything is the same, except for the value of K. The following figure represents the road map in these testcases. Each node denotes a city, with a label of the form "n (m)", where n is the city number, between 1 and N, and m is the number of museums in this city. For example, the node with label "5 (25)" represents city 5, which has 25 museums.
Testcase 1: Lavanya will first choose to fly to city 8. In the first month, they visit only that city, but they visit 150 museums.
Then in the second month, Nikhil could choose to fly to city 3, and they visit the cities 1, 2, 3, 5 and 6, and visit 20 + 0 + 15 + 25 + 30 = 90 museums that month. Note that Nikhil could have instead chosen to fly to city 1 or 2 or 5 or 6, and they would all result in the same scenario.
Then, Lavanya could choose city 7, and in the third month they will visit the cities 7, 4, 10 and 9. Note that Lavanya could have chosen to fly to city 4 or 10 or 9, and they would all result in the same scenario.
In total, they have visited 345 museums in the three months (which is in fact all the museums), and that is the answer.
Testcase 2: It is same as the previous testcase, but now they have only 2 months. So they visit only 150 + 90 = 240 museums in total.
Testcase 3: It is same as the previous testcase, but now they have 5 months of holidays. But sadly, they finish visiting all the cities within the first three months itself, and hence the answer is -1.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
def merge(intervals,start,mid,end):
al = mid-start+1
bl = end-mid
A = intervals[start:mid+1]
B = intervals[mid+1:end+1]
p=0;q=0;k=start;
while(p<al and q<bl):
if(A[p]<B[q]):
intervals[k] = A[p]
k+=1;p+=1;
else:
intervals[k] = B[q]
k+=1;q+=1;
while(p<al):
intervals[k] = A[p]
k+=1;p+=1;
while(q<bl):
intervals[k] = B[q]
k+=1;q+=1;
def mergesort(intervals, start, end):
if(start<end):
mid = int((start+end)/2)
mergesort(intervals,start,mid)
mergesort(intervals,mid+1,end)
merge(intervals,start,mid,end)
t = int(input())
for _ in range(t):
n,m,k = map(int, input().split())
cities = [[0,[]] for i in range(n)]
for i in range(m):
a,b = map(int, input().split())
cities[a-1][1].append(b-1)
cities[b-1][1].append(a-1)
li = list(map(int, input().split()))
def specialfunction():
mergesort(li,0,n-1)
if(k>len(li)):
print(-1)
else:
sum = 0
front = 0
rear = len(li)-1
for i in range(k):
if(i%2==0):
sum += li[rear]
rear -= 1
else:
sum += li[front]
front += 1
print(sum)
if(m == 0):
specialfunction()
continue
for i in range(n):
cities[i][0] = li[i]
visited = [-1 for i in range(n)]
count = 0
museummonths = []
def searchUnvisited():
for i in range(n):
if(visited[i] == -1):
return i
return -1
def bfs(ind,count):
museumcount = 0
queue = []
queue.append(ind)
visited[ind] = 1
museumcount += cities[ind][0]
count += 1
front = 0
rear = 0
while(front<=rear):
noe = len(cities[ind][1])
for i in range(noe):
if(visited[cities[ind][1][i]] == -1):
queue.append(cities[ind][1][i])
rear += 1
count += 1
museumcount += cities[cities[ind][1][i]][0]
visited[cities[ind][1][i]] = 1
front += 1
try:
ind = queue[front]
except:
break
museummonths.append(museumcount)
return count
while(count<n):
for i in range(n):
if(visited[i] == -1):
count = bfs(i,count)
mergesort(museummonths,0,len(museummonths)-1)
#print(museummonths)
if(k>len(museummonths)):
print(-1)
else:
sum = 0
front = 0
rear = len(museummonths)-1
for i in range(k):
if(i%2==0):
sum += museummonths[rear]
rear -= 1
else:
sum += museummonths[front]
front += 1
print(sum)
``` | {
"language": "python",
"test_cases": [
{
"input": "3\n10 10 3\n1 3\n3 5\n5 1\n1 6\n6 2\n5 6\n2 5\n7 10\n4 7\n10 9\n20 0 15 20 25 30 30 150 35 20\n10 10 2\n1 3\n3 5\n5 1\n1 6\n6 2\n5 6\n2 5\n7 10\n4 7\n10 9\n20 0 15 20 25 30 30 150 35 20\n10 10 5\n1 3\n3 5\n5 1\n1 6\n6 2\n5 6\n2 5\n7 10\n4 7\n10 9\n20 0 15 20 25 30 30 150 35 20\n",
"output": "345\n240\n-1\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/INOIPRAC/problems/ROADTRIP"
} | vfc_3882 |
apps | verifiable_code | 1262 | Solve the following coding problem using the programming language python:
An area named Renus, is divided into $(N \times M)$ cells. According to archaeological survey the area contains huge amount of treasure. Some cells out of $(N \times M)$ cells contain treasure. But problem is, you can't go to every cell as some of the cells are blocked.
For every $a_{ij}$ cell($1 \leq i \leq N$,$1 \leq j \leq M$), your task is to find the distance of the nearest cell having treasure.
Note:
- You can only traverse up, down, left and right from a given cell.
- Diagonal movements are not allowed.
- Cells having treasure can't be blocked, only empty cells ( cells without treasure) can be blocked.
-----Input Format:------
- First line contains $T$, the number of test cases.
- Second line contains two space-separated integers $N\ and\ M$.
- Third line contains a single integer $X$ denoting number of cells having treasures, followed by $X$ lines containing two space-separated integers $x_i$ and $y_i$ denoting position of row and column of $i^{th}$ treasure, for every $1\leq i \leq X$
- The next line contains a single integer $Y$ denoting the number of cells that are blocked, and it is followed by subsequent $Y$ lines containing two space-separated integers $u_i$ and $v_i$ denoting position of row and column of blocked cells , for every $1\leq i \leq Y$
-----Constraints:------
- $1\le T \le 100$
- $1 \le N, M \le 200$
- $1 \le X < N*M$
- $0 \le Y <(N*M) - X$
- $1 \le x_i,u_j \le N, for\ every\ 1 \le i \le X\ and\ 1 \le j \le Y$
- $1 \le y_i,v_j \le M, for\ every\ 1 \le i \le X\ and\ 1 \le j \le Y$
-----Output Format:------
For each test case print a $N \times M$ matrix where each cell consists of distance of nearest treasure. Cells that are blocked will show "$X$" (without quotes). Also cells that doesn't have access to any treasure will show "$-1$" (without quotes).
Note: Co-ordinate of top left cell is $(1,1)$.
-----Sample Input-----
1
3 3
2
1 1
1 3
2
2 1
2 2
-----Sample Output-----
0 1 0
X X 1
4 3 2
-----Explanation:-----
- Coordinates (1,1) and (1,3) shows "0" because they contain treasure and nearest distance is 0.
- Coordinates (2,1) and (2,2) shows "X" as they are blocked.
- Rest shows distance of nearest cell having treasure.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
t=int(input())
for _ in range(t):
n,m=[int(x) for x in input().split()]
mat=[]
ans=[]
for i in range(n+2):
l=[]
p=[]
for j in range(m+2):
l.append(0)
p.append(1000000000)
mat.append(l)
ans.append(p)
y=int(input())
for i in range(y):
a,b=[int(x) for x in input().split()]
mat[a][b]=1
ans[a][b]=0
y=int(input())
for i in range(y):
a,b=[int(x) for x in input().split()]
mat[a][b]=1000000000
ans[a][b]=1000000000
for i in range(1,n+1):
for j in range(1,m+1):
if mat[i][j]==1 or mat[i][j]==1000000000:
continue
else:
ans[i][j]=min(ans[i][j],ans[i][j-1]+1,ans[i-1][j]+1)
for i in range(n,0,-1):
for j in range(m,0,-1):
if mat[i][j] == 1 or mat[i][j] == 1000000000:
continue
else:
ans[i][j]=min(ans[i][j],ans[i+1][j]+1,ans[i][j+1]+1)
for i in range(1,n+1):
for j in range(m, 0, -1):
if mat[i][j] == 1 or mat[i][j] == 1000000000:
continue
else:
ans[i][j] = min(ans[i][j], ans[i - 1][j] + 1, ans[i][j + 1] + 1)
for i in range(n, 0, -1):
for j in range(1,m+1):
if mat[i][j] == 1 or mat[i][j] == 1000000000:
continue
else:
ans[i][j] = min(ans[i][j], ans[i + 1][j] + 1, ans[i][j - 1] + 1)
for i in range(1,n+1):
for j in range(1,m+1):
if mat[i][j]==1 or mat[i][j]==1000000000:
continue
else:
ans[i][j]=min(ans[i][j],ans[i][j-1]+1,ans[i-1][j]+1)
for i in range(n,0,-1):
for j in range(m,0,-1):
if mat[i][j] == 1 or mat[i][j] == 1000000000:
continue
else:
ans[i][j]=min(ans[i][j],ans[i+1][j]+1,ans[i][j+1]+1)
for i in range(1,n+1):
for j in range(m, 0, -1):
if mat[i][j] == 1 or mat[i][j] == 1000000000:
continue
else:
ans[i][j] = min(ans[i][j], ans[i - 1][j] + 1, ans[i][j + 1] + 1)
for i in range(n, 0, -1):
for j in range(1,m+1):
if mat[i][j] == 1 or mat[i][j] == 1000000000:
continue
else:
ans[i][j] = min(ans[i][j], ans[i + 1][j] + 1, ans[i][j - 1] + 1)
for i in range(1,n+1):
for j in range(1,m+1):
if mat[i][j]==1000000000:
print('X',end=" ")
elif ans[i][j]>=1000000000:
print('-1',end=" ")
else:
print(ans[i][j],end=" ")
print()
``` | {
"language": "python",
"test_cases": [
{
"input": "1\n3 3\n2\n1 1\n1 3\n2\n2 1\n2 2\n",
"output": "0 1 0\nX X 1\n4 3 2\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/CACD2020/problems/AJP"
} | vfc_3890 |
apps | verifiable_code | 1263 | Solve the following coding problem using the programming language python:
The chef was playing with numbers and he found that natural number N can be obtained by sum various unique natural numbers, For challenging himself chef wrote one problem statement, which he decided to solve in future.
Problem statement: N can be obtained as the sum of Kth power of integers in multiple ways, find total number ways?
After that Cheffina came and read what chef wrote in the problem statement, for having some fun Cheffina made some changes in the problem statement as.
New problem statement: N can be obtained as the sum of Kth power of unique +ve integers in multiple ways, find total number ways?
But, the chef is now confused, how to solve a new problem statement, help the chef to solve this new problem statement.
-----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 to the problem statement.
-----Constraints-----
- $1 \leq T \leq 10$
- $1 \leq N \leq 1000$
- $1 \leq K \leq 6$
-----Sample Input:-----
2
4 1
38 2
-----Sample Output:-----
2
1
-----EXPLANATION:-----
For 1) 4 can be obtained by as [ 4^1 ], [1^1, 3^1], [2^1, 2^1]. (here ^ stands for power)
But here [2^1, 2^1] is not the valid way because it is not made up of unique +ve integers.
For 2) 38 can be obtained in the way which is [2^2, 3^2, 5^2] = 4 + 9 + 25
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())):
x,n = map(int,input().split())
reach = [0]*(x+1)
reach[0] = 1
i=1
while i**n<=x:
j = 1
while j+i**n<=x:
j+=1
j-=1
while j>=0:
if reach[j]>0:
reach[j+i**n]+=reach[j]
j-=1
i+=1
#print(reach)
print(reach[-1])
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n4 1\n38 2\n",
"output": "2\n1\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/PBK22020/problems/ITGUY24"
} | vfc_3894 |
apps | verifiable_code | 1264 | Solve the following coding problem using the programming language python:
Mohit's girlfriend is playing a game with Nicky. The description of the game is as follows:
- Initially on a table Player 1 will put N gem-stones.
- Players will play alternatively, turn by turn.
- At each move a player can take at most M gem-stones (at least 1 gem-stone must be taken) from the available gem-stones on the table.(Each gem-stone has same cost.)
- Each players gem-stone are gathered in player's side.
- The player that empties the table purchases food from it (using all his gem-stones; one gem-stone can buy one unit of food), and the other one puts all his gem-stones back on to the table. Again the game continues with the "loser" player starting.
- The game continues until all the gem-stones are used to buy food.
- The main objective of the game is to consume maximum units of food.
Mohit's girlfriend is weak in mathematics and prediction so she asks help from Mohit, in return she shall kiss Mohit. Mohit task is to predict the maximum units of food her girlfriend can eat, if, she starts first. Being the best friend of Mohit, help him in predicting the answer.
-----Input-----
- Single line contains two space separated integers N and M.
-----Output-----
- The maximum units of food Mohit's girlfriend can eat.
-----Constraints and Subtasks-----
- 1 <= M <= N <= 100
Subtask 1: 10 points
- 1 <= M <= N <= 5
Subtask 2: 20 points
- 1 <= M <= N <= 10
Subtask 3: 30 points
- 1 <= M <= N <= 50
Subtask 3: 40 points
- Original Constraints.
-----Example-----
Input:
4 2
Output:
2
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
r=[0,1,1,2,1,4,2,6,1,8,4]
n,m=[int(x) for x in input().split()]
if m==1:
while n%2!=1:
n=n/2
if n==1:
print(1)
else:
print(n-1)
elif (n+1)/2<m:
print(m)
else:
print(n-m)
``` | {
"language": "python",
"test_cases": [
{
"input": "4 2\n",
"output": "2\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/CDVA16/problems/CDVA1610"
} | vfc_3898 |
apps | verifiable_code | 1265 | Solve the following coding problem using the programming language python:
The Head Chef is receiving a lot of orders for cooking the best of the problems lately. For this, he organized an hiring event to hire some talented Chefs. He gave the following problem to test the skills of the participating Chefs. Can you solve this problem and be eligible for getting hired by Head Chef.
A non-negative number n is said to be magical if it satisfies the following property. Let S denote the multi-set of numbers corresponding to the non-empty subsequences of the digits of the number n in decimal representation. Please note that the numbers in the set S can have leading zeros. Let us take an element s of the multi-set S, prod(s) denotes the product of all the digits of number s in decimal representation.
The number n will be called magical if sum of prod(s) for all elements s in S, is even.
For example, consider a number 246, its all possible non-empty subsequence will be S = {2, 4, 6, 24, 46, 26, 246}. Products of digits of these subsequences will be {prod(2) = 2, prod(4) = 4, prod(6) = 6, prod(24) = 8, prod(46) = 24, prod(26) = 12, prod(246) = 48, i.e. {2, 4, 6, 8, 24, 12, 48}. Sum of all of these is 104, which is even. Hence 246 is a magical number.
Please note that multi-set S can contain repeated elements, e.g. if number is 55, then S = {5, 5, 55}. Products of digits of these subsequences will be {prod(5) = 5, prod(5) = 5, prod(55) = 25}, i.e. {5, 5, 25}. Sum of all of these is 35 which is odd. Hence 55 is not a
magical number.
Consider a number 204, then S = {2, 0, 4, 20, 04, 24, 204}. Products of digits of these subsequences will be {2, 0, 4, 0, 0, 8, 0}. Sum of all these elements will be 14 which is even. So 204 is a magical number.
The task was to simply find the Kth magical number.
-----Input-----
- First line of the input contains an integer T denoting the number of test cases.
- Each of the next T lines contains a single integer K.
-----Output-----
For each test case, print a single integer corresponding to the Kth magical number.
-----Constraints-----
- 1 ≤ T ≤ 105
- 1 ≤ K ≤ 1012.
-----Subtasks-----
Subtask #1 : (20 points)
- 1 ≤ T ≤ 100
- 1 ≤ K ≤ 104.
Subtask 2 : (80 points) Original Constraints
-----Example-----
Input:
2
2
5
Output:
2
8
-----Explanation-----
Example case 1.
2 is the 2nd magical number, since it satisfies the property of the magical number. The first magical number will be of course 0.
The input will be stdin and you should print your solution to stdout
Now solve the problem and return the code. | ```python
def base5(n):
if n == 0: return
for x in base5(n // 5): yield x
yield n % 5
def seq(n):
return int(''.join(str(2 * x) for x in base5(n)) or '0')
for i in range(eval(input())):
k=eval(input())
while(i<k):
i=i+1
print(seq(i-1))
``` | {
"language": "python",
"test_cases": [
{
"input": "2\n2\n5\n\n\n",
"output": "2\n8\n",
"type": "stdin_stdout"
}
]
} | {
"difficulty": "interview",
"problem_url": "https://www.codechef.com/JUNE16/problems/CHEARMY"
} | vfc_3902 |
Subsets and Splits