new soln

Author: shreymehul

2529.MaximumCount.cs

@@ -0,0 +1,78 @@
+// 2529. Maximum Count of Positive Integer and Negative Integer
+// Given an array nums sorted in non-decreasing order, return the maximum between the number of positive integers and the number of negative integers.
+// In other words, if the number of positive integers in nums is pos and the number of negative integers is neg, then return the maximum of pos and neg.
+// Note that 0 is neither positive nor negative.
+// Example 1:
+
+// Input: nums = [-2,-1,-1,1,2,3]
+// Output: 3
+// Explanation: There are 3 positive integers and 3 negative integers. The maximum count among them is 3.
+// Example 2:
+
+// Input: nums = [-3,-2,-1,0,0,1,2]
+// Output: 3
+// Explanation: There are 2 positive integers and 3 negative integers. The maximum count among them is 3.
+// Example 3:
+
+// Input: nums = [5,20,66,1314]
+// Output: 4
+// Explanation: There are 4 positive integers and 0 negative integers. The maximum count among them is 4.
+
+//Linear Search
+public class Solution {
+    public int MaximumCount(int[] nums) {
+        int pos = 0, neg = 0;
+        foreach(int num in nums){
+            if(num < 0) neg++;
+            if(num > 0) pos++;
+        } 
+        return Math.Max(neg,pos);
+    }
+}
+
+//Binary Search
+public class Solution {
+    public int MaximumCount(int[] nums) {
+        int pos = 0, neg = 0;
+        pos = nums.Length - FindFirstPos(nums);
+        pos = pos > nums.Length ? 0 : pos; 
+        neg = FindLastNeg(nums) + 1;
+        return Math.Max(neg,pos);
+    }
+    public int FindLastNeg(int[] nums){
+        int left, right, mid;
+        left = 0;
+        right = nums.Length-1;
+        while(left <= right){
+            mid = left + (right-left)/2;
+            if(nums[mid] < 0 && 
+            ((nums.Length > mid + 1 && nums[mid + 1] >= 0)
+            || nums.Length == mid + 1)){
+                return mid;
+            }
+            else if(nums[mid] < 0)
+                left = mid + 1;
+            else
+                right = mid - 1;
+        }
+        return -1;
+    }
+    public int FindFirstPos(int[] nums){
+        int left, right, mid;
+        left = 0;
+        right = nums.Length-1;
+        while(left <= right){
+            mid = left + (right-left)/2;
+            if(nums[mid] > 0 && 
+            ((mid > 0 && nums[mid - 1] <= 0)
+            || mid == 0)){
+                return mid;
+            }
+            else if(nums[mid] <= 0)
+                left = mid + 1;
+            else
+                right = mid - 1;
+        }
+        return -1;
+    }
+}

350.Intersect.cs

@@ -0,0 +1,35 @@
+// 350. Intersection of Two Arrays II
+// Given two integer arrays nums1 and nums2, return an array of their intersection. Each element in the result must appear as many times as it shows in both arrays and you may return the result in any order.
+
+// Example 1:
+
+// Input: nums1 = [1,2,2,1], nums2 = [2,2]
+// Output: [2,2]
+// Example 2:
+
+// Input: nums1 = [4,9,5], nums2 = [9,4,9,8,4]
+// Output: [4,9]
+// Explanation: [9,4] is also accepted.
+
+public class Solution {
+    public int[] Intersect(int[] nums1, int[] nums2) {
+        Array.Sort(nums1);
+        Array.Sort(nums2);
+        List<int> res = new List<int>();
+        int p1 = 0, p2 = 0;
+        while(p1 < nums1.Length && p2 < nums2.Length){
+            if(nums1[p1] == nums2[p2]){
+                res.Add(nums1[p1]);
+                p1++;
+                p2++;
+            }
+            else{
+                if(nums1[p1] < nums2[p2])
+                    p1++;
+                else
+                    p2++;
+            }
+        } 
+        return res.ToArray();
+    }
+}

485.FindMaxConsecutiveOnes.cs

@@ -20,4 +20,19 @@ public int FindMaxConsecutiveOnes(int[] nums)
         }
         return max;
     }
+}
+
+public class Solution {
+    public int FindMaxConsecutiveOnes(int[] nums) {
+        int max = 0, lmax = 0;
+        foreach(int num in nums){
+            if(num == 0){
+                max = Math.Max(max,lmax);
+                lmax = 0;
+            }
+            else
+                lmax++;
+        }
+        return Math.Max(max,lmax);
+    }
 }

704.BinarySearch.cs

@@ -0,0 +1,32 @@
+// 704. Binary Search
+// Given an array of integers nums which is sorted in ascending order, and an integer target, write a function to search target in nums. If target exists, then return its index. Otherwise, return -1.
+// You must write an algorithm with O(log n) runtime complexity.
+// Example 1:
+
+// Input: nums = [-1,0,3,5,9,12], target = 9
+// Output: 4
+// Explanation: 9 exists in nums and its index is 4
+// Example 2:
+
+// Input: nums = [-1,0,3,5,9,12], target = 2
+// Output: -1
+// Explanation: 2 does not exist in nums so return -1
+
+public class Solution {
+    public int Search(int[] nums, int target) {
+        int left, right, mid;
+        left = 0;
+        right = nums.Length-1;
+        while(left <= right){
+            mid = left + (right-left)/2;
+            if(target == nums[mid]){
+                return mid;
+            }
+            else if(target > nums[mid])
+                left = mid + 1;
+            else
+                right = mid - 1;
+        }
+        return -1;
+    }
+}