Added tasks 50-58

Author: ThanhNIT

LeetCodeNet.Tests/G0001_0100/S0050_powx_n/SolutionTest.cs

@@ -0,0 +1,30 @@
+using Xunit;
+
+namespace LeetCodeNet.G0001_0100.S0050_powx_n {
+    public class SolutionTest {
+        [Fact]
+        public void MyPow_PositiveExponent() {
+            Assert.True(System.Math.Abs(new Solution().MyPow(2.0, 10) - 1024.0) < 1e-5);
+        }
+
+        [Fact]
+        public void MyPow_DecimalBase() {
+            Assert.True(System.Math.Abs(new Solution().MyPow(2.1, 3) - 9.261) < 1e-5);
+        }
+
+        [Fact]
+        public void MyPow_NegativeExponent() {
+            Assert.True(System.Math.Abs(new Solution().MyPow(2.0, -2) - 0.25) < 1e-5);
+        }
+
+        [Fact]
+        public void MyPow_ZeroExponent() {
+            Assert.True(System.Math.Abs(new Solution().MyPow(1.0, 0) - 1.0) < 1e-5);
+        }
+
+        [Fact]
+        public void MyPow_NegativeBase() {
+            Assert.True(System.Math.Abs(new Solution().MyPow(-1.0, 1) - (-1.0)) < 1e-5);
+        }
+    }
+}

LeetCodeNet.Tests/G0001_0100/S0052_n_queens_ii/SolutionTest.cs

@@ -0,0 +1,25 @@
+using Xunit;
+
+namespace LeetCodeNet.G0001_0100.S0052_n_queens_ii {
+    public class SolutionTest {
+        [Fact]
+        public void TotalNQueens_1() {
+            Assert.Equal(1, new Solution().TotalNQueens(1));
+        }
+
+        [Fact]
+        public void TotalNQueens_4() {
+            Assert.Equal(2, new Solution().TotalNQueens(4));
+        }
+
+        [Fact]
+        public void TotalNQueens_5() {
+            Assert.Equal(10, new Solution().TotalNQueens(5));
+        }
+
+        [Fact]
+        public void TotalNQueens_8() {
+            Assert.Equal(92, new Solution().TotalNQueens(8));
+        }
+    }
+}

LeetCodeNet.Tests/G0001_0100/S0054_spiral_matrix/SolutionTest.cs

@@ -0,0 +1,30 @@
+using System.Collections.Generic;
+using Xunit;
+
+namespace LeetCodeNet.G0001_0100.S0054_spiral_matrix {
+    public class SolutionTest {
+        [Fact]
+        public void SpiralOrder_3x3() {
+            var solution = new Solution();
+            int[][] matrix = new int[][] {
+                new int[] {1, 2, 3},
+                new int[] {4, 5, 6},
+                new int[] {7, 8, 9}
+            };
+            var expected = new List<int> {1, 2, 3, 6, 9, 8, 7, 4, 5};
+            Assert.Equal(expected, solution.SpiralOrder(matrix));
+        }
+
+        [Fact]
+        public void SpiralOrder_3x4() {
+            var solution = new Solution();
+            int[][] matrix = new int[][] {
+                new int[] {1, 2, 3, 4},
+                new int[] {5, 6, 7, 8},
+                new int[] {9, 10, 11, 12}
+            };
+            var expected = new List<int> {1, 2, 3, 4, 8, 12, 11, 10, 9, 5, 6, 7};
+            Assert.Equal(expected, solution.SpiralOrder(matrix));
+        }
+    }
+}

LeetCodeNet.Tests/G0001_0100/S0057_insert_interval/SolutionTest.cs

@@ -0,0 +1,39 @@
+using Xunit;
+
+namespace LeetCodeNet.G0001_0100.S0057_insert_interval {
+    public class SolutionTest {
+        [Fact]
+        public void Insert_Overlap() {
+            var solution = new Solution();
+            int[][] intervals = new int[][] {
+                new int[] {1, 3},
+                new int[] {6, 9}
+            };
+            int[] newInterval = new int[] {2, 5};
+            int[][] expected = new int[][] {
+                new int[] {1, 5},
+                new int[] {6, 9}
+            };
+            Assert.Equal(expected, solution.Insert(intervals, newInterval));
+        }
+
+        [Fact]
+        public void Insert_MergeMultiple() {
+            var solution = new Solution();
+            int[][] intervals = new int[][] {
+                new int[] {1, 2},
+                new int[] {3, 5},
+                new int[] {6, 7},
+                new int[] {8, 10},
+                new int[] {12, 16}
+            };
+            int[] newInterval = new int[] {4, 8};
+            int[][] expected = new int[][] {
+                new int[] {1, 2},
+                new int[] {3, 10},
+                new int[] {12, 16}
+            };
+            Assert.Equal(expected, solution.Insert(intervals, newInterval));
+        }
+    }
+}

LeetCodeNet.Tests/G0001_0100/S0058_length_of_last_word/SolutionTest.cs

@@ -0,0 +1,30 @@
+using Xunit;
+
+namespace LeetCodeNet.G0001_0100.S0058_length_of_last_word {
+    public class SolutionTest {
+        [Fact]
+        public void LengthOfLastWord_Normal() {
+            Assert.Equal(5, new Solution().LengthOfLastWord("Hello World"));
+        }
+
+        [Fact]
+        public void LengthOfLastWord_Spaces() {
+            Assert.Equal(4, new Solution().LengthOfLastWord("   fly me   to   the moon  "));
+        }
+
+        [Fact]
+        public void LengthOfLastWord_MultipleWords() {
+            Assert.Equal(6, new Solution().LengthOfLastWord("luffy is still joyboy"));
+        }
+
+        [Fact]
+        public void LengthOfLastWord_SingleChar() {
+            Assert.Equal(1, new Solution().LengthOfLastWord("a"));
+        }
+
+        [Fact]
+        public void LengthOfLastWord_OnlySpaces() {
+            Assert.Equal(0, new Solution().LengthOfLastWord(" "));
+        }
+    }
+}

LeetCodeNet/G0001_0100/S0050_powx_n/Solution.cs

@@ -0,0 +1,23 @@
+namespace LeetCodeNet.G0001_0100.S0050_powx_n {
+
+// #Medium #Top_Interview_Questions #Math #Recursion #Udemy_Integers #Top_Interview_150_Math
+// #2025_07_01_Time_0_ms_(100.00%)_Space_29.14_MB_(83.57%)
+
+public class Solution {
+    public double MyPow(double x, int n) {
+        if (n == 0) return 1.0;
+        long N = n;
+        if (N < 0) {
+            x = 1 / x;
+            N = -N;
+        }
+        double result = 1.0;
+        while (N > 0) {
+            if ((N & 1) == 1) result *= x;
+            x *= x;
+            N >>= 1;
+        }
+        return result;
+    }
+}
+}

LeetCodeNet/G0001_0100/S0050_powx_n/readme.md

@@ -0,0 +1,31 @@
+50\. Pow(x, n)
+
+Medium
+
+Implement [pow(x, n)](http://www.cplusplus.com/reference/valarray/pow/), which calculates `x` raised to the power `n` (i.e., <code>x<sup>n</sup></code>).
+
+**Example 1:**
+
+**Input:** x = 2.00000, n = 10
+
+**Output:** 1024.00000 
+
+**Example 2:**
+
+**Input:** x = 2.10000, n = 3
+
+**Output:** 9.26100 
+
+**Example 3:**
+
+**Input:** x = 2.00000, n = -2
+
+**Output:** 0.25000
+
+**Explanation:** 2<sup>\-2</sup> = 1/2<sup>2</sup> = 1/4 = 0.25 
+
+**Constraints:**
+
+*   `-100.0 < x < 100.0`
+*   <code>-2<sup>31</sup> <= n <= 2<sup>31</sup>-1</code>
+*   <code>-10<sup>4</sup> <= x<sup>n</sup> <= 10<sup>4</sup></code>

LeetCodeNet/G0001_0100/S0052_n_queens_ii/Solution.cs

@@ -0,0 +1,28 @@
+namespace LeetCodeNet.G0001_0100.S0052_n_queens_ii {
+
+// #Hard #Backtracking #Top_Interview_150_Backtracking
+// #2025_07_01_Time_1_ms_(95.31%)_Space_29.22_MB_(64.06%)
+
+public class Solution {
+    public int TotalNQueens(int n) {
+        int count = 0;
+        Solve(0, n, new bool[n], new bool[2 * n], new bool[2 * n], ref count);
+        return count;
+    }
+
+    private void Solve(int row, int n, bool[] cols, bool[] d1, bool[] d2, ref int count) {
+        if (row == n) {
+            count++;
+            return;
+        }
+        for (int col = 0; col < n; col++) {
+            int id1 = col - row + n;
+            int id2 = col + row;
+            if (cols[col] || d1[id1] || d2[id2]) continue;
+            cols[col] = d1[id1] = d2[id2] = true;
+            Solve(row + 1, n, cols, d1, d2, ref count);
+            cols[col] = d1[id1] = d2[id2] = false;
+        }
+    }
+}
+}

LeetCodeNet/G0001_0100/S0052_n_queens_ii/readme.md

@@ -0,0 +1,27 @@
+52\. N-Queens II
+
+Hard
+
+The **n-queens** puzzle is the problem of placing `n` queens on an `n x n` chessboard such that no two queens attack each other.
+
+Given an integer `n`, return _the number of distinct solutions to the **n-queens puzzle**_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/11/13/queens.jpg)
+
+**Input:** n = 4
+
+**Output:** 2
+
+**Explanation:** There are two distinct solutions to the 4-queens puzzle as shown. 
+
+**Example 2:**
+
+**Input:** n = 1
+
+**Output:** 1 
+
+**Constraints:**
+
+*   `1 <= n <= 9`

LeetCodeNet/G0001_0100/S0054_spiral_matrix/Solution.cs

@@ -0,0 +1,32 @@
+using System.Collections.Generic;
+
+namespace LeetCodeNet.G0001_0100.S0054_spiral_matrix {
+
+// #Medium #Top_100_Liked_Questions #Top_Interview_Questions #Array #Matrix #Simulation
+// #Programming_Skills_II_Day_8 #Level_2_Day_1_Implementation/Simulation #Udemy_2D_Arrays/Matrix
+// #Top_Interview_150_Matrix #2025_07_01_Time_0_ms_(100.00%)_Space_46.80_MB_(7.91%)
+
+public class Solution {
+    public IList<int> SpiralOrder(int[][] matrix) {
+        var res = new List<int>();
+        if (matrix == null || matrix.Length == 0) return res;
+        int m = matrix.Length, n = matrix[0].Length;
+        int top = 0, bottom = m - 1, left = 0, right = n - 1;
+        while (top <= bottom && left <= right) {
+            for (int j = left; j <= right; j++) res.Add(matrix[top][j]);
+            top++;
+            for (int i = top; i <= bottom; i++) res.Add(matrix[i][right]);
+            right--;
+            if (top <= bottom) {
+                for (int j = right; j >= left; j--) res.Add(matrix[bottom][j]);
+                bottom--;
+            }
+            if (left <= right) {
+                for (int i = bottom; i >= top; i--) res.Add(matrix[i][left]);
+                left++;
+            }
+        }
+        return res;
+    }
+}
+}