Added tasks 152-200

Author: javadev

LeetCodeNet.Tests/G0101_0200/S0152_maximum_product_subarray/SolutionTest.cs

@@ -0,0 +1,16 @@
+namespace LeetCodeNet.G0101_0200.S0152_maximum_product_subarray {
+
+using Xunit;
+
+public class SolutionTest {
+    [Fact]
+    public void MaxProduct() {
+        Assert.Equal(6, new Solution().MaxProduct(new int[] {2, 3, -2, 4}));
+    }
+
+    [Fact]
+    public void MaxProduct2() {
+        Assert.Equal(0, new Solution().MaxProduct(new int[] {-2, 0, -1}));
+    }
+}
+}

LeetCodeNet.Tests/G0101_0200/S0153_find_minimum_in_rotated_sorted_array/SolutionTest.cs

@@ -0,0 +1,21 @@
+namespace LeetCodeNet.G0101_0200.S0153_find_minimum_in_rotated_sorted_array {
+
+using Xunit;
+
+public class SolutionTest {
+    [Fact]
+    public void FindMin() {
+        Assert.Equal(1, new Solution().FindMin(new int[] {3, 4, 5, 1, 2}));
+    }
+
+    [Fact]
+    public void FindMin2() {
+        Assert.Equal(0, new Solution().FindMin(new int[] {4, 5, 6, 7, 0, 1, 2}));
+    }
+
+    [Fact]
+    public void FindMin3() {
+        Assert.Equal(11, new Solution().FindMin(new int[] {11, 13, 15, 17}));
+    }
+}
+}

LeetCodeNet.Tests/G0101_0200/S0155_min_stack/MinStackTest.cs

@@ -0,0 +1,21 @@
+namespace LeetCodeNet.G0101_0200.S0155_min_stack {
+
+using Xunit;
+
+public class MinStackTest {
+    [Fact]
+    public void MinStack() {
+        MinStack minStack = new MinStack();
+        minStack.Push(-2);
+        minStack.Push(0);
+        minStack.Push(-3);
+        // return -3
+        Assert.Equal(-3, minStack.GetMin());
+        minStack.Pop();
+        // return 0
+        Assert.Equal(0, minStack.Top());
+        // return -2
+        Assert.Equal(-2, minStack.GetMin());
+    }
+}
+}

LeetCodeNet.Tests/G0101_0200/S0160_intersection_of_two_linked_lists/SolutionTest.cs

@@ -0,0 +1,22 @@
+namespace LeetCodeNet.G0101_0200.S0160_intersection_of_two_linked_lists {
+
+using Xunit;
+using LeetCodeNet.Com_github_leetcode;
+
+public class SolutionTest {
+    [Fact]
+    public void GetIntersectionNode() {
+        ListNode intersectionListNode = new ListNode(8, new ListNode(4, new ListNode(5)));
+        ListNode nodeA = new ListNode(4, new ListNode(1, intersectionListNode));
+        ListNode nodeB = new ListNode(5, new ListNode(6, new ListNode(1, intersectionListNode)));
+        Assert.Equal(8, new Solution().GetIntersectionNode(nodeA, nodeB).val);
+    }
+
+    [Fact]
+    public void GetIntersectionNode2() {
+        ListNode nodeA = new ListNode(4, new ListNode(1, new ListNode(2)));
+        ListNode nodeB = new ListNode(5, new ListNode(6, new ListNode(1, new ListNode(2))));
+        Assert.Equal(null, new Solution().GetIntersectionNode(nodeA, nodeB));
+    }
+}
+}

LeetCodeNet.Tests/G0101_0200/S0169_majority_element/SolutionTest.cs

@@ -0,0 +1,16 @@
+namespace LeetCodeNet.G0101_0200.S0169_majority_element {
+
+using Xunit;
+
+public class SolutionTest {
+    [Fact]
+    public void MajorityElement() {
+        Assert.Equal(3, new Solution().MajorityElement(new int[] {3, 2, 3}));
+    }
+
+    [Fact]
+    public void MajorityElement2() {
+        Assert.Equal(2, new Solution().MajorityElement(new int[] {2, 2, 1, 1, 1, 2, 2}));
+    }
+}
+}

LeetCodeNet.Tests/G0101_0200/S0189_rotate_array/SolutionTest.cs

@@ -0,0 +1,20 @@
+namespace LeetCodeNet.G0101_0200.S0189_rotate_array {
+
+using Xunit;
+
+public class SolutionTest {
+    [Fact]
+    public void Rotate() {
+        int[] array = new int[] {1, 2, 3, 4, 5, 6, 7};
+        new Solution().Rotate(array, 3);
+        Assert.Equal(new int[] {5, 6, 7, 1, 2, 3, 4}, array);
+    }
+
+    [Fact]
+    public void Rotate2() {
+        int[] array = new int[] {-1, -100, 3, 99};
+        new Solution().Rotate(array, 2);
+        Assert.Equal(new int[] {3, 99, -1, -100}, array);
+    }
+}
+}

LeetCodeNet.Tests/G0101_0200/S0198_house_robber/SolutionTest.cs

@@ -0,0 +1,16 @@
+namespace LeetCodeNet.G0101_0200.S0198_house_robber {
+
+using Xunit;
+
+public class SolutionTest {
+    [Fact]
+    public void Rob() {
+        Assert.Equal(4, new Solution().Rob(new int[] {1, 2, 3, 1}));
+    }
+
+    [Fact]
+    public void Rob2() {
+        Assert.Equal(12, new Solution().Rob(new int[] {2, 7, 9, 3, 1}));
+    }
+}
+}

LeetCodeNet.Tests/G0101_0200/S0200_number_of_islands/SolutionTest.cs

@@ -0,0 +1,28 @@
+namespace LeetCodeNet.G0101_0200.S0200_number_of_islands {
+
+using Xunit;
+
+public class SolutionTest {
+    [Fact]
+    public void NumIslands() {
+        char[][] grid = new char[][] {
+            new char[] {'1', '1', '1', '1', '0'},
+            new char[] {'1', '1', '0', '1', '0'},
+            new char[] {'1', '1', '0', '0', '0'},
+            new char[] {'0', '0', '0', '0', '0'}
+        };
+        Assert.Equal(1, new Solution().NumIslands(grid));
+    }
+
+    [Fact]
+    public void NumIslands2() {
+        char[][] grid = new char[][] {
+            new char[] {'1', '1', '0', '0', '0'},
+            new char[] {'1', '1', '0', '0', '0'},
+            new char[] {'0', '0', '1', '0', '0'},
+            new char[] {'0', '0', '0', '1', '1'}
+        };
+        Assert.Equal(3, new Solution().NumIslands(grid));
+    }
+}
+}

LeetCodeNet/G0101_0200/S0152_maximum_product_subarray/Solution.cs

@@ -0,0 +1,29 @@
+namespace LeetCodeNet.G0101_0200.S0152_maximum_product_subarray {
+
+// #Medium #Top_100_Liked_Questions #Top_Interview_Questions #Array #Dynamic_Programming
+// #Dynamic_Programming_I_Day_6 #Level_2_Day_13_Dynamic_Programming #Udemy_Dynamic_Programming
+// #Big_O_Time_O(N)_Space_O(1) #2024_01_11_Time_71_ms_(90.35%)_Space_42.7_MB_(13.88%)
+
+public class Solution {
+    public int MaxProduct(int[] nums) {
+        int ans = int.MinValue;
+        int cprod = 1;
+        foreach (int j in nums) {
+            cprod = cprod * j;
+            ans = Math.Max(ans, cprod);
+            if (cprod == 0) {
+                cprod = 1;
+            }
+        }
+        cprod = 1;
+        for (int i = nums.Length - 1; i >= 0; i--) {
+            cprod = cprod * nums[i];
+            ans = Math.Max(ans, cprod);
+            if (cprod == 0) {
+                cprod = 1;
+            }
+        }
+        return ans;
+    }
+}
+}

LeetCodeNet/G0101_0200/S0152_maximum_product_subarray/readme.md

@@ -0,0 +1,31 @@
+152\. Maximum Product Subarray
+
+Medium
+
+Given an integer array `nums`, find a contiguous non-empty subarray within the array that has the largest product, and return _the product_.
+
+It is **guaranteed** that the answer will fit in a **32-bit** integer.
+
+A **subarray** is a contiguous subsequence of the array.
+
+**Example 1:**
+
+**Input:** nums = [2,3,-2,4]
+
+**Output:** 6
+
+**Explanation:** [2,3] has the largest product 6. 
+
+**Example 2:**
+
+**Input:** nums = [-2,0,-1]
+
+**Output:** 0
+
+**Explanation:** The result cannot be 2, because [-2,-1] is not a subarray. 
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 2 * 10<sup>4</sup></code>
+*   `-10 <= nums[i] <= 10`
+*   The product of any prefix or suffix of `nums` is **guaranteed** to fit in a **32-bit** integer.