@@ -13,6 +13,7 @@ This repository contains solutions to various LeetCode problems implemented in C
 | 42 | [Trapping Rain Water](https://leetcode.com/problems/trapping-rain-water/) | Hard | [Code](https://github.com/gabaoalb/LeetCodeCSharp/blob/main/Solutions/Problems/TrappingRainWater.cs) |
 | 49 | [Group Anagrams](https://leetcode.com/problems/group-anagrams/) | Medium | [Code](https://github.com/gabaoalb/LeetCodeCSharp/blob/main/Solutions/Problems/GroupAnagrams.cs) |
 | 104 | [Maximum Depth of Binary Tree](https://leetcode.com/problems/maximum-depth-of-binary-tree/) | Easy | [Code](https://github.com/gabaoalb/LeetCodeCSharp/blob/main/Solutions/Problems/MaximumDepthOfBinaryTree.cs) |
+| 125 | [Valid Palindrome](https://leetcode.com/problems/valid-palindrome/) | Easy | [Code](https://github.com/gabaoalb/LeetCodeCSharp/blob/main/Solutions/Problems/ValidPalindrome.cs) |
 | 128 | [Longest Consecutive Sequence](https://leetcode.com/problems/longest-consecutive-sequence/) | Medium | [Code](https://github.com/gabaoalb/LeetCodeCSharp/blob/main/Solutions/Problems/LongestConsecutiveSequence.cs) |
 | 217 | [Contains Duplicate](https://leetcode.com/problems/contains-duplicate/) | Easy | [Code](https://github.com/gabaoalb/LeetCodeCSharp/blob/main/Solutions/Problems/ContainsDuplicate.cs) |
 | 226 | [Invert Binary Tree](https://leetcode.com/problems/invert-binary-tree/) | Easy | [Code](https://github.com/gabaoalb/LeetCodeCSharp/blob/main/Solutions/Problems/InvertBinaryTree.cs) |
 
@@ -0,0 +1,47 @@
+using Solutions.Problems;
+
+namespace Solutions.Tests.Problems;
+
+public class ValidPalindromeTest
+{
+    public ValidPalindromeSolution Solution { get; } = new();
+
+    [Fact]
+    public void Case1()
+    {
+        // Arrange
+        string s = "A man, a plan, a canal: Panama";
+
+        // Act
+        bool result = Solution.IsPalindrome(s);
+
+        // Assert
+        Assert.True(result);
+    }
+
+    [Fact]
+    public void Case2()
+    {
+        // Arrange
+        string s = "race a car";
+
+        // Act
+        bool result = Solution.IsPalindrome(s);
+
+        // Assert
+        Assert.False(result);
+    }
+
+    [Fact]
+    public void Case3()
+    {
+        // Arrange
+        string s = " ";
+
+        // Act
+        bool result = Solution.IsPalindrome(s);
+
+        // Assert
+        Assert.True(result);
+    }
+}
@@ -0,0 +1,40 @@
+namespace Solutions.Problems;
+
+public class ValidPalindromeSolution
+{
+    /// <summary>
+    /// Reverse string approach to determine if a given string is a palindrome, considering only alphanumeric characters and ignoring cases.
+    /// Time complexity: O(n), where n is the length of the input string. This is because we need to traverse the string once to clean it and then potentially traverse it again to reverse it.
+    /// Space complexity: O(n) in the worst case, where n is the length of
+    /// </summary>
+    /// <param name="s"></param>
+    /// <returns></returns>
+    public bool IsPalindromeReverse(string s)
+    {
+        string clean = new([.. s.ToLower().Where(char.IsLetterOrDigit)]);
+        string reverse = new([.. clean.Reverse()]);
+        return clean == reverse;
+    }
+
+    /// <summary>
+    /// Two pointers approach to determine if a given string is a palindrome, considering only alphanumeric characters and ignoring cases.
+    /// Time complexity: O(n), where n is the length of the input string. This is because we need to traverse the string once to clean it and then potentially traverse it again with the two pointers.
+    /// Space complexity: O(n) in the worst case, where n is the length of the input string. This occurs when all characters are alphanumeric and need to be stored in the cleaned string. However, if we consider only the additional space used for variables, it is O(1).
+    /// </summary>
+    /// <param name="s">The input string to be checked for palindrome properties.</param>
+    /// <returns>True if the input string is a palindrome, false otherwise.</returns>
+    public bool IsPalindrome(string s)
+    {
+        string clean = new([.. s.ToLower().Where(char.IsLetterOrDigit)]);
+        (int left, int right) = (0, clean.Length - 1);
+
+        while (left < right)
+        {
+            if (clean[left] != clean[right]) return false;
+            left++;
+            right--;
+        }
+
+        return true;
+    }
+}