Add files via upload

shashankch292 · web-flow · commit 5e968199ca01 · 2018-08-20T19:41:35.000+05:30
diff --git a/Greedy/AssignMiceToHoles.cpp b/Greedy/AssignMiceToHoles.cpp
@@ -0,0 +1,46 @@
+/*
+There are N Mice and N holes are placed in a straight line. 
+Each hole can accomodate only 1 mouse. 
+A mouse can stay at his position, move one step right from x to x + 1, or move one step left from x to x − 1. Any of these moves consumes 1 minute.
+Assign mice to holes so that the time when the last mouse gets inside a hole is minimized.
+
+Example:
+
+positions of mice are:
+4 -4 2
+positions of holes are:
+4 0 5
+
+Assign mouse at position x=4 to hole at position x=4 : Time taken is 0 minutes 
+Assign mouse at position x=-4 to hole at position x=0 : Time taken is 4 minutes 
+Assign mouse at position x=2 to hole at position x=5 : Time taken is 3 minutes 
+After 4 minutes all of the mice are in the holes.
+
+Since, there is no combination possible where the last mouse's time is less than 4, 
+answer = 4.
+Input:
+
+A :  list of positions of mice
+B :  list of positions of holes
+Output:
+
+single integer value
+ NOTE: The final answer will fit in a 32 bit signed integer. 
+
+LINK: https://www.interviewbit.com/problems/assign-mice-to-holes/
+*/
+
+int Solution::mice(vector<int> &A, vector<int> &B)
+{
+    int n = A.size();
+ 
+    sort(A.begin(), A.end());
+    sort(B.begin(), B.end());
+ 
+    int ans = -1;
+ 
+    for(int i=0;i<n;i++)
+        ans = max(ans, abs(A[i]-B[i]));
+ 
+    return ans;
+}
diff --git a/Greedy/Bulbs.cpp b/Greedy/Bulbs.cpp
@@ -0,0 +1,36 @@
+/*
+N light bulbs are connected by a wire. Each bulb has a switch associated with it, however due to faulty wiring, a switch also changes the state of all the bulbs to the right of current bulb. Given an initial state of all bulbs, find the minimum number of switches you have to press to turn on all the bulbs. You can press the same switch multiple times.
+
+Note : 0 represents the bulb is off and 1 represents the bulb is on.
+
+Example:
+
+Input : [0 1 0 1]
+Return : 4
+
+Explanation :
+	press switch 0 : [1 0 1 0]
+	press switch 1 : [1 1 0 1]
+	press switch 2 : [1 1 1 0]
+	press switch 3 : [1 1 1 1]
+
+LINK: https://www.interviewbit.com/problems/bulbs/
+*/
+
+int Solution::bulbs(vector<int> &A) 
+{
+    int n = A.size();
+    int sum = 0;
+    int temp = 1;
+ 
+    for(int i=0;i<n;i++)
+    {
+        if(A[i]^temp)
+        {
+            sum++;
+            temp ^= 1;
+        }
+    }
+ 
+    return sum;
+}
diff --git a/Greedy/DistributeCandy.cpp b/Greedy/DistributeCandy.cpp
@@ -0,0 +1,40 @@
+/*
+There are N children standing in a line. Each child is assigned a rating value.
+
+ You are giving candies to these children subjected to the following requirements:
+Each child must have at least one candy.
+Children with a higher rating get more candies than their neighbors.
+What is the minimum candies you must give?
+
+Sample Input :
+
+Ratings : [1 2]
+Sample Output :
+
+3
+The candidate with 1 rating gets 1 candy and candidate with rating cannot get 1 candy as 1 is its neighbor. So rating 2 candidate gets 2 candies. In total, 2+1 = 3 candies need to be given out.
+
+LINK: https://www.interviewbit.com/problems/distribute-candy/
+*/
+
+int Solution::candy(vector<int> &A)
+{
+    int n = A.size();
+ 
+    vector<int> l(n,1), r(n,1);
+ 
+    for(int i=1;i<n;i++)
+        if(A[i] > A[i-1])
+            l[i] = l[i-1] + 1;
+ 
+    for(int i=n-2;i>=0;i--)
+        if(A[i] > A[i+1])
+            r[i] = r[i+1] + 1;
+ 
+    int ans = 0;
+ 
+    for(int i=0;i<n;i++)
+        ans += max(l[i], r[i]);
+ 
+    return ans;
+}
diff --git a/Greedy/GasStation.cpp b/Greedy/GasStation.cpp
@@ -0,0 +1,49 @@
+/*
+There are N gas stations along a circular route, where the amount of gas at station i is gas[i].
+
+You have a car with an unlimited gas tank and it costs cost[i] of gas to travel from station i to its next station (i+1). You begin the journey with an empty tank at one of the gas stations.
+
+Return the minimum starting gas station’s index if you can travel around the circuit once, otherwise return -1.
+
+You can only travel in one direction. i to i+1, i+2, ... n-1, 0, 1, 2..
+Completing the circuit means starting at i and ending up at i again.
+
+Example :
+
+Input :
+      Gas :   [1, 2]
+      Cost :  [2, 1]
+
+Output : 1 
+
+If you start from index 0, you can fill in gas[0] = 1 amount of gas. Now your tank has 1 unit of gas. But you need cost[0] = 2 gas to travel to station 1. 
+If you start from index 1, you can fill in gas[1] = 2 amount of gas. Now your tank has 2 units of gas. You need cost[1] = 1 gas to get to station 0. So, you travel to station 0 and still have 1 unit of gas left over. You fill in gas[0] = 1 unit of additional gas, making your current gas = 2. It costs you cost[0] = 2 to get to station 1, which you do and complete the circuit. 
+
+LINK: https://www.interviewbit.com/problems/gas-station/
+*/
+
+int Solution::canCompleteCircuit(const vector<int> &A, const vector<int> &B)
+{
+    int n = A.size();
+    int gasToReach = 0;
+    int total = 0;
+    int start = 0;
+ 
+    for(int i=0;i<n;i++)
+    {
+        int gas = (A[i]-B[i]);
+        total += gas;
+ 
+        if(gasToReach < 0)
+        {
+            gasToReach = gas;
+            start = i;
+        }
+        else
+            gasToReach += gas;
+    }
+ 
+    if(total < 0)
+        return -1;
+    return start;
+}
diff --git a/Greedy/HighestProduct.cpp b/Greedy/HighestProduct.cpp
@@ -0,0 +1,24 @@
+/*
+Given an array of integers, return the highest product possible by multiplying 3 numbers from the array
+
+Input:
+
+array of integers e.g {1, 2, 3}
+ NOTE: Solution will fit in a 32-bit signed integer 
+Example:
+
+[0, -1, 3, 100, 70, 50]
+
+=> 70*50*100 = 350000
+
+LINK: https://www.interviewbit.com/problems/highest-product/
+*/
+
+int Solution::maxp3(vector<int> &A)
+{
+    int n = A.size();
+ 
+    sort(A.begin(), A.end());
+ 
+    return max(A[n-1]*A[n-2]*A[n-3], A[n-1]*A[0]*A[1]);
+}
diff --git a/Greedy/MajorityElement.cpp b/Greedy/MajorityElement.cpp
@@ -0,0 +1,35 @@
+/*
+Given an array of size n, find the majority element. The majority element is the element that appears more than floor(n/2) times.
+
+You may assume that the array is non-empty and the majority element always exist in the array.
+
+Example :
+
+Input : [2, 1, 2]
+Return  : 2 which occurs 2 times which is greater than 3/2. 
+
+LINK: https://www.interviewbit.com/problems/majority-element/
+*/
+
+int Solution::majorityElement(const vector<int> &A)
+{
+    int n = A.size();
+    int cnt = 1;
+    int majInd = 0;
+ 
+    for(int i=1;i<n;i++)
+    {
+        if(A[majInd]==A[i])
+            cnt++;
+        else
+            cnt--;
+ 
+        if(cnt==0)
+        {
+            cnt = 1;
+            majInd = i;
+        }
+    }
+ 
+    return A[majInd];
+}
diff --git a/Greedy/Seats.cpp b/Greedy/Seats.cpp
@@ -0,0 +1,88 @@
+/*
+There is a row of seats. Assume that it contains N seats adjacent to each other. There is a group of people who are already seated in that row randomly. i.e. some are sitting together & some are scattered.
+
+An occupied seat is marked with a character 'x' and an unoccupied seat is marked with a dot ('.')
+
+Now your target is to make the whole group sit together i.e. next to each other, without having any vacant seat between them in such a way that the total number of hops or jumps to move them should be minimum.
+
+Return minimum value % MOD where MOD = 10000003
+
+Example
+
+Here is the row having 15 seats represented by the String (0, 1, 2, 3, ......... , 14) -
+
+              . . . . x . . x x . . . x . .
+
+Now to make them sit together one of approaches is -
+                  . . . . . . x x x x . . . . .
+
+Following are the steps to achieve this -
+1 - Move the person sitting at 4th index to 6th index -  
+    Number of jumps by him =   (6 - 4) = 2
+
+2 - Bring the person sitting at 12th index to 9th index - 
+    Number of jumps by him = (12 - 9) = 3
+
+So now the total number of jumps made = 
+    ( 2 + 3 ) % MOD = 
+    5 which is the minimum possible jumps to make them seat together.
+
+There are also other ways to make them sit together but the number of jumps will exceed 5 and that will not be minimum.
+
+For example bring them all towards the starting of the row i.e. start placing them from index 0. 
+In that case the total number of jumps will be 
+    ( 4 + 6 + 6 + 9 )%MOD 
+    = 25 which is very costly and not an optimized way to do this movement
+
+LINK: https://www.interviewbit.com/problems/seats/
+*/
+
+#define MOD 10000003
+ 
+int Solution::seats(string A)
+{
+    int n = A.size();
+    vector<int> prsn;
+ 
+    for(int i=0;i<n;i++)
+    {
+        if(A[i] == 'x')
+            prsn.push_back(i);
+    }
+ 
+    int m = prsn.size();
+ 
+    if(m==0)
+        return 0;
+ 
+    int median = prsn[m/2];
+ 
+    if(m/2==0)
+        median = (prsn[m/2-1] + prsn[m/2])/2;
+ 
+    int ans = 0;
+ 
+    int emptyInd = A[median]=='.' ? median : median-1;
+ 
+    for(int i=median-1;i>=0;i--)
+    {
+        if(A[i]=='x')
+        {
+            ans = (ans + (emptyInd - i))%MOD;
+            emptyInd--;
+        }
+    }
+ 
+    emptyInd = median + 1;
+ 
+    for(int i=median+1;i<n;i++)
+    {
+        if(A[i]=='x')
+        {
+            ans = (ans + (i - emptyInd))%MOD;
+            emptyInd++;
+        }
+    }
+ 
+    return ans;
+}
