costest

Author: KB-perByte

Gen2_0_PP/Contest/closesprimeNo2.py

@@ -0,0 +1,93 @@
+'''
+There is a straight line with N points. A coin is located at each point starting from 1 and ending at N.
+
+At N+1 th position, an additional M coins are kept.
+
+A person starts walking with a bag from position 0 towards position N+1. At each position, i where 1 <= i <= N :
+
+He collects the coin present at the position i.
+
+If i divides both N and M, he empties his bag by throwing away all the coins he had collected till now.
+
+Finally he collects the M coins present at position N+1.
+
+Can you tell how many coins does the person has at the end of this process?
+
+Input Format
+
+The first line of input contains an integer T, which denotes the number of test cases.
+
+Each line of test cases contains two integers N and M.
+
+Constraints
+
+1 <= T <= 10
+
+1 <= N <= 10^10
+
+1 <= M <= 10^6
+
+Output Format
+
+For each test case, in a separate line, output the number of coins that the person has after following the steps mentioned in the problem statement.
+
+Sample Input 0
+
+3
+1 5
+2 3
+5 5
+Sample Output 0
+
+5
+4
+5
+Explanation 0
+
+Case 2: The person starts at position 1. He collects coin 1. 2%1 == 0 and 3%1 == 0. So, he throws away the collected coin.
+
+Next, he goes to 2. 3%2 != 0. He has 1 coin.
+
+Next, he collects the 3 remaining coins. So, total coins = 4.
+'''
+import math 
+
+def sumOfDigitsFrom1ToN(n) : 
+	if (n<10) : 
+		return (n*(n+1)/2) 
+	d = (int)(math.log10(n)) 
+	a = [0] * (d + 1) 
+	a[0] = 0
+	a[1] = 45
+	for i in range(2, d+1) : 
+		a[i] = a[i-1] * 10 + 45 * (int)(math.ceil(math.pow(10,i-1))) 
+	p = (int)(math.ceil(math.pow(10, d))) 
+	msd = n//p 
+	return (int)(msd * a[d] + (msd*(msd-1) // 2) * p +
+		msd * (1 + n % p) + sumOfDigitsFrom1ToN(n % p)) 
+
+def compute_hcf(x, y):
+   while(y):
+       x, y = y, x % y
+   return x
+
+t = int(input())
+while(t):
+    t-=1
+    arr = []
+    # arr = list(map(int,input().split()))
+    # a = compute_hcf(arr[0], arr[1])
+    # _a = sumOfDigitsFrom1ToN(a)
+    # _a1 = sumOfDigitsFrom1ToN(arr[0])
+
+    # if int(_a1 - _a) == 0:
+    #     print(int(arr[1]))
+    # else:
+    #print((int(_a1 - _a)-1)+int(arr[1]))
+
+    arr = list(map(int,input().split()))
+    a = compute_hcf(arr[0], arr[1])
+    print(int((arr[0] - a) + arr[1]))
+
+
+

Gen2_0_PP/Contest/collectTheCoins.py

@@ -0,0 +1,44 @@
+
+#include<bits/stdc++.h>
+#include<algorithm>
+using namespace std;
+#define int long long int
+#define vi vector<int>
+int32_t main()
+{
+ ios_base::sync_with_stdio(false);cin.tie(NULL); cout.tie(NULL);
+  int n,m;
+   cin>>n>>m;
+    vi group(n);
+    for(int i=0;i<n;i++) cin>>group[i];
+    vi pref(n);
+    pref[0]=group[0];
+    for(int i=1;i<n;i++)
+    {
+        pref[i]= pref[i-1]+group[i];
+    }
+    while(m--)
+    {
+        int x;cin>>x;
+        auto lb= lower_bound(pref.begin(),pref.end(),x);
+        int len= lb-pref.begin();
+        cout<<len+1<<" "<<*lb-x<<endl;
+    }
+    
+}
+
+
+
+
+
+# function to find cumulative sum of array 
+from itertools import accumulate 
+prfixsim = []
+def cumulativeSum(input): 
+	print ("Sum :", list(accumulate(input))) 
+    
+# Driver program 
+if __name__ == "__main__": 
+	input = [4, 6, 12] 
+	cumulativeSum(input) 
+    (list(accumulate(input)))

Gen2_0_PP/Contest/findTheWorkshop.cpp

@@ -0,0 +1,76 @@
+'''
+Programming Pathshala has launched N workshops. Each of the courses have a seat limit represented by an array of integers a[i]
+
+To segregate students into batches for these workshops, they have conducted a contest. The students with ranks 1 to a[0] will be a part of the first workshop, those with ranks between a[0] + 1 and a[0] + a[1] will be a part of the second workshop and so on.
+
+Given rank of M different students, for each of them, find the workshop number and his/her rank in that workshop batch.
+
+For example, if the limits of workshops are represented by [30, 20, 30, 10], if a person has rank 40, he will be a part of the second workshop and will have 10th rank in the workshop.
+
+Note that the rank will always be within the maximum number of seats in the workshop.
+
+Input Format
+
+The first line of input consists of two integers N and M, the number of workshops and the number of queries.
+
+The next line of input consists of N space separated integers, denoting the number of seats in each of the workshop, array a[i].
+
+The next line of input consists of M space separated integers, denoting the ranks of the student for which we have queried, represented by array b[i].
+
+Constraints
+
+1 <= N, M <= 200000
+
+1 <= a[i] <= 10^10
+
+1 <= b[i] <= sum(a[i])
+
+Output Format
+
+For each of the M queries, output 2 space separated integers in a new line denoting the workshop number and the person's rank in the workshop.
+
+Sample Input 0
+
+4 2
+30 20 30 10
+85 40
+Sample Output 0
+
+4 5
+2 10
+Explanation 0
+
+In this case, students with rank (1, 30) will be in first group.
+
+Those with ranks in (31, 50) will be in second group.
+
+Those with ranks in (51, 80) will be in third group.
+
+Those with ranks in (81, 90) will be in fourth group
+'''
+from itertools import accumulate
+from bisect import bisect_right, bisect_left
+
+input1 = list(map(int,input().split()))
+input2 = list(map(int,input().split()))
+
+prefixSm = []
+prefixSm = (list(accumulate(input2)))
+
+input3 = list(map(int,input().split()))
+
+def findLowerbound(a, x):
+    i = bisect_left(a, x)
+    if i != len(a):
+        if i == 0:
+            return i+1 , x
+        else:
+            return i+1 , x - a[i-1]
+
+#print("prefix sum", prefixSm)
+for i in range(len(input3)):
+    workshopNo , rank = findLowerbound(prefixSm, input3[i])
+    print(workshopNo, rank)
+    
+
+

Gen2_0_PP/Contest/findTheWorkshop2.py

@@ -0,0 +1,77 @@
+'''
+There has been a recent codeforces contest that the students of the Genesis 1.0 have attempted.
+
+After the contest, they are trying to predict their ratings. There has been a hack in the codeforces server that will lead to the rating of every person after the contest getting updated to the closest prime number to their rating before the contest.
+
+In case, there are multiple ratings closest to the initial rating that are prime, the hacker has ensured that the rating will be updated to the lowest one.
+
+Can you help the participants to determine their rating after the contest?
+
+Input Format
+
+The first line of input contains T, the number of students who wants to calculate their ratings.
+
+The next T lines contain integer N, rating of the person.
+
+Constraints
+
+1 <= T <= 1000
+
+1 <= N <= 1000000
+
+Output Format
+
+Output T lines, each line containing the result of the ith query.
+
+Sample Input 0
+
+3
+10
+20
+30
+Sample Output 0
+
+11
+19
+29
+Explanation 0
+
+For the first test case, since the number 11 is closer to 10, than 7 (|11-10|<|10-7|), thus 11 is the correct answer.
+
+Simlilarly for second test case.
+
+For the third test case, since 2 closest primes are possible (viz. 29 and 31), we report the smaller one i.e 29.
+
+Submissions: 38
+Max Score: 100
+Difficulty: Medium
+Rate This Challenge:
+
+    
+More
+ 
+'''
+def getPrimes(limit):
+    primes = []
+    numbers = [True] * limit
+    for i in range(2, limit):
+        if numbers[i]:
+            primes.append(i)
+            for n in range(i ** 2, limit, i):
+                numbers[n] = False
+    return primes
+
+
+t = int(input())
+while(t):
+    t-=1
+    number = int(input())
+    primes = getPrimes(number + 100)
+    maxDist = 99999999
+    numb = 0
+    for p in primes:
+        if abs(number - p) < maxDist:
+            maxDist = abs(number - p)
+            numb = p
+
+    print(numb)