new soln

Author: shreymehul

2300.SuccessfulPairs.cs

@@ -0,0 +1,65 @@
+// 2300. Successful Pairs of Spells and Potions
+// You are given two positive integer arrays spells and potions, of length n and m respectively, where spells[i] represents the strength of the ith spell and potions[j] represents the strength of the jth potion.// You are also given an integer success. A spell and potion pair is considered successful if the product of their strengths is at least success.
+// Return an integer array pairs of length n where pairs[i] is the number of potions that will form a successful pair with the ith spell.
+
+// Example 1:
+// Input: spells = [5,1,3], potions = [1,2,3,4,5], success = 7
+// Output: [4,0,3]
+// Explanation:
+// - 0th spell: 5 * [1,2,3,4,5] = [5,10,15,20,25]. 4 pairs are successful.
+// - 1st spell: 1 * [1,2,3,4,5] = [1,2,3,4,5]. 0 pairs are successful.
+// - 2nd spell: 3 * [1,2,3,4,5] = [3,6,9,12,15]. 3 pairs are successful.
+// Thus, [4,0,3] is returned.
+// Example 2:
+// Input: spells = [3,1,2], potions = [8,5,8], success = 16
+// Output: [2,0,2]
+// Explanation:
+// - 0th spell: 3 * [8,5,8] = [24,15,24]. 2 pairs are successful.
+// - 1st spell: 1 * [8,5,8] = [8,5,8]. 0 pairs are successful. 
+// - 2nd spell: 2 * [8,5,8] = [16,10,16]. 2 pairs are successful. 
+// Thus, [2,0,2] is returned.
+
+// Constraints:
+// n == spells.length
+// m == potions.length
+// 1 <= n, m <= 105
+// 1 <= spells[i], potions[i] <= 105
+// 1 <= success <= 1010
+public class Solution {
+    public int[] SuccessfulPairs(int[] spells, int[] potions, long success) {
+        // Sort the potions array
+        Array.Sort(potions);
+        
+        // Initialize the array to store the results
+        int[] successPair = new int[spells.Length];
+        
+        // Iterate through each spell
+        for(int i = 0; i < spells.Length; i++){
+            // Perform a binary search to find the minimum index of the potion that meets the success criteria
+            int min = BinarySearch(potions, spells[i], success);
+            // Calculate the number of successful pairs
+            successPair[i] = potions.Length - min;
+        }
+        
+        // Return the array with the counts of successful pairs
+        return successPair;
+    }
+    
+    // Helper method to perform binary search
+    private int BinarySearch(int[] potions, int spell, long success) {
+        int left = 0;
+        int right = potions.Length;
+        
+        // Perform binary search
+        while (left < right) {
+            int mid = left + (right - left) / 2;
+            if ((long) spell * potions[mid] >= success) {
+                right = mid; // Look for a smaller index on the left side
+            } else {
+                left = mid + 1; // Look for a larger index on the right side
+            }
+        }
+        
+        return left;
+    }
+}

826.MaxProfitAssignment.cs

@@ -0,0 +1,77 @@
+// 826. Most Profit Assigning Work
+// You have n jobs and m workers. You are given three arrays: difficulty, profit, and worker where:
+
+// difficulty[i] and profit[i] are the difficulty and the profit of the ith job, and
+// worker[j] is the ability of jth worker (i.e., the jth worker can only complete a job with difficulty at most worker[j]).
+// Every worker can be assigned at most one job, but one job can be completed multiple times.
+// For example, if three workers attempt the same job that pays $1, then the total profit will be $3. If a worker cannot complete any job, their profit is $0.
+// Return the maximum profit we can achieve after assigning the workers to the jobs.
+
+ // Example 1:
+// Input: difficulty = [2,4,6,8,10], profit = [10,20,30,40,50], worker = [4,5,6,7]
+// Output: 100
+// Explanation: Workers are assigned jobs of difficulty [4,4,6,6] and they get a profit of [20,20,30,30] separately.
+// Example 2:
+// Input: difficulty = [85,47,57], profit = [24,66,99], worker = [40,25,25]
+// Output: 0
+
+// Constraints:
+// n == difficulty.length
+// n == profit.length
+// m == worker.length
+// 1 <= n, m <= 104
+// 1 <= difficulty[i], profit[i], worker[i] <= 105
+
+public class Solution {
+    public int MaxProfitAssignment(int[] difficulty, int[] profit, int[] worker) {
+    
+        Array.Sort(difficulty, profit);
+        Array.Sort(worker);
+
+        int netProfit = 0;
+        int maxProfit = 0;
+        int k = 0;
+
+        foreach (int w in worker) {
+            while (k < difficulty.Length && w >= difficulty[k]) {
+                maxProfit = Math.Max(maxProfit, profit[k]);
+                k++;
+            }
+            netProfit += maxProfit;
+        }
+
+        return netProfit;
+    }
+}
+
+
+public class Solution {
+    public int MaxProfitAssignment(int[] difficulty, int[] profit, int[] worker) {
+        List<int[]> diffProfit = new List<int[]>();
+        for (int i = 0; i < difficulty.Length; i++) {
+            diffProfit.Add(new int[] { difficulty[i], profit[i] });
+        }
+
+        // Sort by difficulty first, then by profit in descending order
+        diffProfit.Sort((a, b) => {
+            if (a[0] == b[0]) return b[1].CompareTo(a[1]);
+            return a[0].CompareTo(b[0]);
+        });
+
+        Array.Sort(worker);
+
+        int netProfit = 0;
+        int maxProfit = 0;
+        int k = 0;
+
+        foreach (int w in worker) {
+            while (k < diffProfit.Count && w >= diffProfit[k][0]) {
+                maxProfit = Math.Max(maxProfit, diffProfit[k][1]);
+                k++;
+            }
+            netProfit += maxProfit;
+        }
+
+        return netProfit;
+    }
+}