Added more stuff

Author: Mehulcoder

Bit Manipulation/Unset.cpp

@@ -36,6 +36,8 @@ int turnOffIthBit(int n, int i){
     return (n & ~(1 << (i))); 
 
 }
+
+
 int main( int argc , char ** argv )
 {
 	ios_base::sync_with_stdio(false) ; 
@@ -49,9 +51,4 @@ int main( int argc , char ** argv )
 
 	return 0;
 
-
-	
-
-
-
 }

Greedy/Problemdiscussion.cpp

@@ -0,0 +1,104 @@
+/*
+
+				Name: Mehul Chaturvedi
+				IIT-Guwahati
+
+*/
+
+/*
+				PROBLEM STATEMENT
+Harshit gave Aahad an array of size N and asked to minimize the difference between the maximum 
+value and minimum value by modifying the array under the condition that each array element either 
+increase or decrease by k(only once).
+It seems difficult for Aahad so he asked for your help
+Input Format
+The First line contains two space-separated integers: N,K
+Next lines contain N space-separated integers denoting elements of the array
+Output Format
+The output contains a single integer denoting the minimum difference between maximum value and 
+the minimum value in the array
+Constraints
+1 =< N <= 10^5 
+1 <= Ai,K <= 10^9
+Sample Input1:
+3 6
+1 15 10
+Sample Output1:
+5
+Explaination
+We change from 1 to 6, 15 to  9 and 10 to 4. Maximum difference is 5 (between 4 and 9). We can't 
+get a lower difference.
+
+*/
+
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+int getMinDiff(int arr[], int n, int k) 
+{ 
+    if (n == 1) 
+       return 0; 
+  
+    // Sort all elements 
+    sort(arr, arr+n); 
+  
+    // Initialize result 
+    int ans = arr[n-1] - arr[0]; 
+  
+    // Handle corner elements 
+    int small = arr[0] + k; 
+    int big = arr[n-1] - k; 
+    if (small > big) 
+       swap(small, big); 
+  
+    // Traverse middle elements 
+    for (int i = 1; i < n-1; i ++) 
+    { 
+        int subtract = arr[i] - k; 
+        int add = arr[i] + k; 
+  
+        // If both subtraction and addition 
+        // do not change diff 
+        if (subtract >= small || add <= big) 
+            continue; 
+  
+        // Either subtraction causes a smaller 
+        // number or addition causes a greater 
+        // number. Update small or big using 
+        // greedy approach (If big - subtract 
+        // causes smaller diff, update small 
+        // Else update big) 
+        if (big - subtract <= add - small) 
+            small = subtract; 
+        else
+            big = add; 
+    } 
+  
+    return  min(ans, big - small); 
+} 
+
+int main( int argc , char ** argv )
+{
+	ios_base::sync_with_stdio(false) ; 
+	cin.tie(NULL) ; 
+	
+	int n,k;
+	cin>>n>>k;
+
+	int* arr = new int[n];
+	
+	for (int i = 0; i < n; ++i)
+	{
+		cin>>arr[i];
+	}
+
+	cout << getMinDiff(arr, n, k) << '\n';
+
+
+	return 0 ; 
+
+
+
+}

adhoc problems/Circularlist.cpp

@@ -0,0 +1,68 @@
+/*
+
+				Name: Mehul Chaturvedi
+				IIT-Guwahati
+
+*/
+
+/*
+				PROBLEM STATEMENT
+You are given a circular list of students as follows:
+0 -> 1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7 -> 8 -> 9 -> 10 -> 11
+This list is circular, means that 11 will follow 0 again. You will be given the student number ‘i’ and 
+some position ‘p’. You will have to tell that if the list will start from (i+1)th student, 
+then which student will be at pth position.
+Input Format:
+First line will have an integer ‘t’, denoting the number of test cases.
+Next line will have two space separated integers denoting the value of ‘i’ and ‘p’ respectively.
+Output Format:
+Print ‘t’ lines containing single integer denoting the student number.
+Constraints:
+1 <= t <= 10^5
+0 <= i <= 11
+1 <= p <= 12
+Sample Input:
+2
+2 3
+5 8
+Sample Output:
+5
+1
+Explanation:
+First, list will start at 3. 3 -> 4 -> 5. Hence, 5 will be at third position.
+Second, list will start at 6. 6 -> 7 -> 8 -> 9 -> 10 -> 11 -> 0 -> 1. Hence, 1 will be at 8th 
+position.
+*/
+
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+int go(int i, int p){
+	int ans = (i+p)%12
+	return ans;
+}
+
+
+int main( int argc , char ** argv )
+{
+	ios_base::sync_with_stdio(false) ; 
+	cin.tie(NULL) ; 
+	
+	int t;
+	cin>>t;
+
+	while(t--){
+		int i, p;
+		cin>>i>>p;
+
+		cout << go(i, p) << '\n';
+	}
+
+
+	return 0 ; 
+
+
+
+}

adhoc problems/Intrestingsequences.cpp

@@ -0,0 +1,140 @@
+/*
+
+				Name: Mehul Chaturvedi
+				IIT-Guwahati
+
+*/
+
+/*
+				PROBLEM STATEMENT
+Professor Jain has a class full of notorious students. To get anything done from them is a herculean task. Prof Jain wanted to organize a test. He gave this responsibility to Aahad. Aahad did an excellent job of organizing the test. As a reward, the professor gave him an sequence of numbers to play with. But Aahad likes playing with "interesting" sequence of numbers, which are sequences that have equal elements.
+Now, the problem is - Prof Jain has a sequence with elements, and that sequence isn't always "interesting”. To ensure sequence has equal elements, Prof Jain has 2 options:
+1) Choose two elements of sequence . DECREASE the first element by 1 and INCREASE the second element by 1. This operation costs 'k' coins.
+2) Choose one element of array and INCREASE it by 1. This operation costs 'l' coins.
+What’s the minimum number of coins Prof Jain needs to turn his sequence into a “interesting" sequence for Aahad?
+Input Format
+The first line of input contains three space-separated integers: n, k, l . Integer n is the size of array . Integer k is the number of coins needed to perform the first operation. Integer l is the number of coins needed to perform the second operation.
+
+The second line contains n integers: (a1, a2, a3... an) representing sequence.
+Constraints:
+1 <= n, k, l <= 1000
+1 <= ai <= 1000
+Time Limit: 1 second
+Output Format
+In single line, print one integer number: the minimum number of coins required to make "interesting" sequence.
+Sample Test Cases:
+Sample Input 1:
+4 1 2
+3 4 2 2
+Sample Output 1:
+3
+Explanation Output 1 :
+The professor has a sequence with 4 elements. To perform the first operation, they must pay 1 coin and to perform the second operation, they must pay 2 coins. The optimal strategy is:
+
+-Perform the second operation on the fourth element. Now the sequence is {3, 4, 2, 3}. This costs 2 coins.
+
+-Perform the first operation on the second and third element. The sequence is now "interesting", and it looks like {3, 3, 3, 3}. This costs 1 coin. 
+
+The total amount of coins needed is 2 + 1 = 3.
+Sample Input 2:
+3 2 1
+5 5 5
+Sample Output 2:
+0
+Explanation Output 2 :
+The given sequence is already "interesting". The professor would spend 0 coins.
+Sample Input 3:
+5 2 1
+1 2 3 4 5
+Sample Output 3:
+6
+Explanation Output 3 :
+The professor has a sequence with 5 elements. To perform the first operation, they must pay 2 coin and to perform the second operation, they must pay 1 coin. The optimal strategy is:
+
+-Perform the first operation on the first and last element. Now the sequence is {2, 2, 3, 4, 4}. This costs 2 coins.
+
+-Perform the first operation again on the first and last element. Now the sequence is {3, 2, 3, 4, 3}. This costs 2 coins.
+
+-Perform the first operation on the second and second last element. Now the sequence is {3, 3, 3, 3, 3}. This costs 2 coins.
+
+The total amount of coins needed is 2 + 2 + 2 = 6.
+*/
+
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+int go(int* arr, int n, int k, int l){
+	int maximum = arr[0];
+	int minimum = arr[0];
+	for (int i = 0; i < n; ++i)
+	{
+		maximum = max(arr[i], maximum);
+		minimum = min(arr[i], minimum);
+	}
+	// cout << maximum << '\n';
+	// cout << minimum << '\n';
+	
+	int ans = INT_MAX;
+
+	for (int number = minimum; number <= maximum; ++number)
+	{
+		//cout << "here" << '\n';
+		int increase = 0;
+		int decrease = 0;
+		for (int i = 0; i < n; ++i)
+		{
+			if (arr[i]>number)
+			{
+				decrease += arr[i]-number;
+			}else if (arr[i]<number)
+			{
+				increase += number-arr[i];
+			}
+		}
+		 cout << "Decrease: "<<decrease << '\n';
+		 cout << "Increase: "<<increase << '\n';
+
+		if (decrease>increase)
+		{
+			continue;
+		}
+		int cost = 0;
+
+		cost = decrease*k + (increase-decrease)*l;
+		// cout << "cost: "<<cost << '\n';
+		ans = min(ans, cost);
+
+
+	}
+
+	return ans;
+
+}
+
+
+int main( int argc , char ** argv )
+{
+	ios_base::sync_with_stdio(false) ; 
+	cin.tie(NULL) ; 
+	
+	int n, k, l;
+
+	cin>>n>>k>>l;
+	int* arr = new int[n];
+
+	for (int i = 0; i < n; ++i)
+	{
+		cin>>arr[i];
+	}
+
+	cout << go(arr, n, k, l) << '\n';
+
+	delete [] arr;
+
+	return 0 ; 
+
+
+
+}

adhoc problems/Test.txt

@@ -0,0 +1,2 @@
+4 1000 0
+3 4 2 2