Update articles (#5566)

* Update articles

* update articles

Author: Srihari2222

articles/height-checker.md

@@ -96,6 +96,25 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public int HeightChecker(int[] heights) {
+        int[] expected = new int[heights.Length];
+        Array.Copy(heights, expected, heights.Length);
+        Array.Sort(expected);
+
+        int res = 0;
+        for (int i = 0; i < heights.Length; i++) {
+            if (heights[i] != expected[i]) {
+                res++;
+            }
+        }
+
+        return res;
+    }
+}
+```
+
 ```go
 func heightChecker(heights []int) int {
     expected := make([]int, len(heights))
@@ -303,6 +322,34 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public int HeightChecker(int[] heights) {
+        int[] count = new int[101];
+        foreach (int h in heights) {
+            count[h]++;
+        }
+
+        List<int> expected = new List<int>();
+        for (int h = 1; h <= 100; h++) {
+            int c = count[h];
+            for (int i = 0; i < c; i++) {
+                expected.Add(h);
+            }
+        }
+
+        int res = 0;
+        for (int i = 0; i < heights.Length; i++) {
+            if (heights[i] != expected[i]) {
+                res++;
+            }
+        }
+
+        return res;
+    }
+}
+```
+
 ```go
 func heightChecker(heights []int) int {
     count := make([]int, 101)

articles/maximum-twin-sum-of-a-linked-list.md

@@ -154,6 +154,43 @@ class Solution {
 }
 ```
 
+```csharp
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     public int val;
+ *     public ListNode next;
+ *     public ListNode(int val=0, ListNode next=null) {
+ *         this.val = val;
+ *         this.next = next;
+ *     }
+ * }
+ */
+
+public class Solution {
+    public int PairSum(ListNode head) {
+        List<int> arr = new List<int>();
+        ListNode cur = head;
+
+        while (cur != null) {
+            arr.Add(cur.val);
+            cur = cur.next;
+        }
+
+        int i = 0, j = arr.Count - 1;
+        int res = 0;
+
+        while (i < j) {
+            res = Math.Max(res, arr[i] + arr[j]);
+            i++;
+            j--;
+        }
+
+        return res;
+    }
+}
+```
+
 ```go
 /**
  * Definition for singly-linked list.
@@ -466,6 +503,50 @@ class Solution {
 }
 ```
 
+```csharp
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     public int val;
+ *     public ListNode next;
+ *     public ListNode(int val=0, ListNode next=null) {
+ *         this.val = val;
+ *         this.next = next;
+ *     }
+ * }
+ */
+
+public class Solution {
+    public int PairSum(ListNode head) {
+        ListNode slow = head, fast = head;
+
+        while (fast != null && fast.next != null) {
+            slow = slow.next;
+            fast = fast.next.next;
+        }
+
+        ListNode prev = null, cur = slow;
+        while (cur != null) {
+            ListNode nxt = cur.next;
+            cur.next = prev;
+            prev = cur;
+            cur = nxt;
+        }
+
+        int res = 0;
+        ListNode first = head, second = prev;
+
+        while (second != null) {
+            res = Math.Max(res, first.val + second.val);
+            first = first.next;
+            second = second.next;
+        }
+
+        return res;
+    }
+}
+```
+
 ```go
 /**
  * Definition for singly-linked list.
@@ -782,6 +863,45 @@ class Solution {
 }
 ```
 
+```csharp
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     public int val;
+ *     public ListNode next;
+ *     public ListNode(int val=0, ListNode next=null) {
+ *         this.val = val;
+ *         this.next = next;
+ *     }
+ * }
+ */
+
+public class Solution {
+    public int PairSum(ListNode head) {
+        ListNode slow = head, fast = head;
+        ListNode prev = null;
+
+        while (fast != null && fast.next != null) {
+            fast = fast.next.next;
+            ListNode tmp = slow.next;
+            slow.next = prev;
+            prev = slow;
+            slow = tmp;
+        }
+
+        int res = 0;
+
+        while (slow != null) {
+            res = Math.Max(res, prev.val + slow.val);
+            prev = prev.next;
+            slow = slow.next;
+        }
+
+        return res;
+    }
+}
+```
+
 ```go
 /**
  * Definition for singly-linked list.

articles/pascals-triangle-ii.md

@@ -103,7 +103,7 @@ class Solution {
 
 ```csharp
 public class Solution {
-    public IList<int> GetRow(int rowIndex) {
+    public List<int> GetRow(int rowIndex) {
         if (rowIndex == 0) return new List<int> { 1 };
 
         var curRow = new List<int> { 1 };
@@ -284,7 +284,7 @@ class Solution {
 
 ```csharp
 public class Solution {
-    public IList<int> GetRow(int rowIndex) {
+    public List<int> GetRow(int rowIndex) {
         var res = new List<int[]>();
         for (int i = 0; i <= rowIndex; i++) {
             int[] row = new int[i + 1];
@@ -462,7 +462,7 @@ class Solution {
 
 ```csharp
 public class Solution {
-    public IList<int> GetRow(int rowIndex) {
+    public List<int> GetRow(int rowIndex) {
         var res = new List<int> { 1 };
         for (int i = 0; i < rowIndex; i++) {
             var nextRow = new List<int>(new int[res.Count + 1]);
@@ -627,7 +627,7 @@ class Solution {
 
 ```csharp
 public class Solution {
-    public IList<int> GetRow(int rowIndex) {
+    public List<int> GetRow(int rowIndex) {
         var row = new List<int>(new int[rowIndex + 1]);
         for (int i = 0; i <= rowIndex; i++) row[i] = 1;
         for (int i = 1; i < rowIndex; i++) {
@@ -778,7 +778,7 @@ class Solution {
 
 ```csharp
 public class Solution {
-    public IList<int> GetRow(int rowIndex) {
+    public List<int> GetRow(int rowIndex) {
         var row = new List<int> { 1 };
         for (int i = 1; i <= rowIndex; i++) {
             row.Add((int)((long)row[row.Count - 1] * (rowIndex - i + 1) / i));

articles/products-of-array-discluding-self.md

@@ -248,7 +248,7 @@ So we first check how many zeros the array has:
         - The index with zero gets the `prod` of all non-zero numbers.
         - All other positions get `0`.
     - If there are no zeros:
-        - Set each result value to `prod / nums[i]`.
+        - Set each result value to `prod // nums[i]`.
 5. Return the result array.
 
 ::tabs-start