{"id":943,"date":"2025-04-11T09:06:22","date_gmt":"2025-04-11T08:06:22","guid":{"rendered":"https:\/\/debuggersspace.com\/?p=943"},"modified":"2025-04-11T09:06:22","modified_gmt":"2025-04-11T08:06:22","slug":"30-algorithm-challenges-in-c-with-real-world-examples-code","status":"publish","type":"post","link":"https:\/\/debuggersspace.com\/index.php\/2025\/04\/11\/30-algorithm-challenges-in-c-with-real-world-examples-code\/","title":{"rendered":"30 Algorithm Challenges in C# (With Real-World Examples & Code)"},"content":{"rendered":"
\n
\n \t<\/i> Read Time:<\/span>19 Minute, 9 Second <\/div>\n\n <\/div>

\u2728 Part 1: Linked Lists & Arrays (Problems 1\u20135)<\/b><\/strong><\/h1>\n

\u2705 1. Reverse a Linked List<\/b><\/strong><\/h2>\n

\ufffd\ufffd\ufffd Problem Statement:
\nYou are given the head of a singly linked list. You need to reverse the list so that the last node becomes the first, and each node points to the previous one.<\/p>\n

\ufffd\ufffd\ufffd Approach:
\nWe\u2019ll use three pointers:
\n– prev (initially null),
\n– current (starts from head),
\n– next (temporarily stores the next node).
\nWe loop through the list and reverse each pointer one by one.<\/p>\n

\ufffd\ufffd\ufffd Program (C#):<\/p>\n

public class ListNode
\n{
\npublic int val;
\npublic ListNode next;
\npublic ListNode(int val = 0, ListNode next = null)
\n{
\nthis.val = val;
\nthis.next = next;
\n}
\n}<\/p>\n

public class Solution
\n{
\npublic ListNode ReverseList(ListNode head)
\n{
\nListNode prev = null;
\nListNode current = head;<\/p>\n

while (current != null)
\n{
\nListNode next = current.next;
\ncurrent.next = prev;
\nprev = current;
\ncurrent = next;
\n}<\/p>\n

return prev;
\n}
\n}<\/p>\n

\ufffd\ufffd\ufffd Explanation:
\nWe reverse the list by adjusting the next pointer of each node to point to the previous node. At the end of the loop, prev becomes the new head of the reversed list.<\/p>\n

 <\/p>\n

\u2705 2. Check if a String Has All Unique Characters<\/b><\/strong><\/h2>\n

\ufffd\ufffd\ufffd Problem Statement:
\nYou are given a string. Check if all characters in the string are unique \u2014 no character should repeat.<\/p>\n

\ufffd\ufffd\ufffd Approach:
\nUse a simple nested loop to compare each character with the rest (no dictionaries used).<\/p>\n

\ufffd\ufffd\ufffd Program (C#):<\/p>\n

public class Solution
\n{
\npublic bool HasAllUniqueCharacters(string input)
\n{
\nfor (int i = 0; i < input.Length; i++)
\n{
\nfor (int j = i + 1; j < input.Length; j++)
\n{
\nif (input[i] == input[j])
\nreturn false;
\n}
\n}
\nreturn true;
\n}
\n}<\/p>\n

\ufffd\ufffd\ufffd Explanation:
\nWe loop through every character and compare it with all characters after it. If we find any repetition, return false.<\/p>\n

 <\/p>\n

\u2705 3. Find the Missing Number in an Array<\/b><\/strong><\/h2>\n

\ufffd\ufffd\ufffd Problem Statement:
\nYou are given an array of n distinct numbers from 0 to n. One number is missing. Find that missing number.<\/p>\n

\ufffd\ufffd\ufffd Approach:
\nCalculate the sum of numbers from 0 to n using the formula: sum = n * (n + 1) \/ 2. Then subtract the sum of the given array.<\/p>\n

\ufffd\ufffd\ufffd Program (C#):<\/p>\n

public class Solution
\n{
\npublic int FindMissingNumber(int[] nums)
\n{
\nint n = nums.Length;
\nint totalSum = n * (n + 1) \/ 2;
\nint arraySum = 0;<\/p>\n

for (int i = 0; i < nums.Length; i++)
\n{
\narraySum += nums[i];
\n}<\/p>\n

return totalSum – arraySum;
\n}
\n}<\/p>\n

\ufffd\ufffd\ufffd Explanation:
\nThe difference between expected total and actual total gives us the missing number in the range.<\/p>\n

 <\/p>\n

\u2705 4. Validate if a String Has Balanced Parentheses<\/b><\/strong><\/h2>\n

\ufffd\ufffd\ufffd Problem Statement:
\nYou are given a string containing parentheses \u2014 (), {}, []. Check whether the string is balanced, meaning every opening has a corresponding closing bracket in the correct order.<\/p>\n

\ufffd\ufffd\ufffd Approach:
\nUse a manual stack simulation (array + pointer) to push opening brackets and pop them on matching closing ones.<\/p>\n

\ufffd\ufffd\ufffd Program (C#):<\/p>\n

public class Solution
\n{
\npublic bool IsBalanced(string s)
\n{
\nchar[] stack = new char[s.Length];
\nint top = -1;<\/p>\n

foreach (char ch in s)
\n{
\nif (ch == ‘(‘ || ch == ‘{‘ || ch == ‘[‘)
\n{
\nstack[++top] = ch;
\n}
\nelse
\n{
\nif (top == -1) return false;<\/p>\n

char open = stack[top–];<\/p>\n

if ((ch == ‘)’ && open != ‘(‘) ||
\n(ch == ‘}’ && open != ‘{‘) ||
\n(ch == ‘]’ && open != ‘[‘))
\n{
\nreturn false;
\n}
\n}
\n}<\/p>\n

return top == -1;
\n}
\n}<\/p>\n

\ufffd\ufffd\ufffd Explanation:
\nWe push opening brackets and pop on matching closings. If mismatch or leftover items exist in the stack, the string is not balanced.<\/p>\n

 <\/p>\n

\u2705 5. Merge Two Sorted Arrays<\/b><\/strong><\/h2>\n

\ufffd\ufffd\ufffd Problem Statement:
\nYou are given two sorted arrays. Merge them into one sorted array.<\/p>\n

\ufffd\ufffd\ufffd Approach:
\nUse two pointers to compare both arrays and insert smaller elements one by one into a result array.<\/p>\n

\ufffd\ufffd\ufffd Program (C#):<\/p>\n

public class Solution
\n{
\npublic int[] MergeSortedArrays(int[] arr1, int[] arr2)
\n{
\nint[] result = new int[arr1.Length + arr2.Length];
\nint i = 0, j = 0, k = 0;<\/p>\n

while (i < arr1.Length && j < arr2.Length)
\n{
\nif (arr1[i] < arr2[j])
\nresult[k++] = arr1[i++];
\nelse
\nresult[k++] = arr2[j++];
\n}<\/p>\n

while (i < arr1.Length)
\nresult[k++] = arr1[i++];<\/p>\n

while (j < arr2.Length)
\nresult[k++] = arr2[j++];<\/p>\n

return result;
\n}
\n}<\/p>\n

\ufffd\ufffd\ufffd Explanation:
\nWe maintain three indices. The smallest current element is copied into the result array. Remaining items (if any) are copied after one array finishes.<\/p>\n

\u2728 Part 2: String & Pattern Problems (Problems 6\u201310)<\/b><\/strong><\/h1>\n

\u2705 6. Validate Palindrome (case-insensitive, ignore punctuation)<\/b><\/strong><\/h2>\n

\ufffd\ufffd\ufffd Problem Statement:
\nGiven a string, check whether it is a palindrome. A palindrome reads the same backward as forward. Ignore cases and non-alphanumeric characters.<\/p>\n

\ufffd\ufffd\ufffd Approach:
\nWe can use two pointers: one starting from the beginning and one from the end. Skip characters that are not letters or digits and compare the remaining ones in lowercase.<\/p>\n

\ufffd\ufffd\ufffd Program (C#):<\/p>\n

public class Solution
\n{
\npublic bool IsPalindrome(string s)
\n{
\nint left = 0, right = s.Length – 1;<\/p>\n

while (left < right)
\n{
\nwhile (left < right && !char.IsLetterOrDigit(s[left])) left++;
\nwhile (left < right && !char.IsLetterOrDigit(s[right])) right–;<\/p>\n

if (char.ToLower(s[left]) != char.ToLower(s[right]))
\nreturn false;<\/p>\n

left++;
\nright–;
\n}<\/p>\n

return true;
\n}
\n}<\/p>\n

\ufffd\ufffd\ufffd Explanation:
\nWe skip non-alphanumeric characters and compare the valid ones after converting to lowercase. If all characters match as we move inward, it\u2019s a palindrome.<\/p>\n

 <\/p>\n

\u2705 7. Reverse Words in a Sentence (preserve character order)<\/b><\/strong><\/h2>\n

\ufffd\ufffd\ufffd Problem Statement:
\nYou are given a string containing words separated by spaces. Reverse the words’ positions while preserving the characters inside each word.<\/p>\n

\ufffd\ufffd\ufffd Approach:
\nSplit the string by spaces, reverse the array of words, then join them back together with a single space.<\/p>\n

\ufffd\ufffd\ufffd Program (C#):<\/p>\n

public class Solution
\n{
\npublic string ReverseWords(string sentence)
\n{
\nstring[] words = sentence.Split(‘ ‘);
\nArray.Reverse(words);
\nreturn string.Join(” “, words);
\n}
\n}<\/p>\n

\ufffd\ufffd\ufffd Explanation:
\nWe split the sentence into an array of words, reverse the array, and rejoin the words using spaces.<\/p>\n

 <\/p>\n

\u2705 8. Remove Duplicate Words from an Array<\/b><\/strong><\/h2>\n

\ufffd\ufffd\ufffd Problem Statement:
\nGiven an array of words, remove all duplicate words and return the result.<\/p>\n

\ufffd\ufffd\ufffd Approach:
\nUse a simple loop to add only the first occurrence of each word to the result array.<\/p>\n

\ufffd\ufffd\ufffd Program (C#):<\/p>\n

public class Solution
\n{
\npublic string[] RemoveDuplicates(string[] words)
\n{
\nList<string> result = new List<string>();<\/p>\n

for (int i = 0; i < words.Length; i++)
\n{
\nbool found = false;
\nfor (int j = 0; j < result.Count; j++)
\n{
\nif (result[j] == words[i])
\n{
\nfound = true;
\nbreak;
\n}
\n}
\nif (!found)
\nresult.Add(words[i]);
\n}<\/p>\n

return result.ToArray();
\n}
\n}<\/p>\n

\ufffd\ufffd\ufffd Explanation:
\nWe check each word against the result list. If not already present, we add it. This avoids using HashSet or dictionary.<\/p>\n

 <\/p>\n

\u2705 9. Count Occurrences of Characters (case-insensitive)<\/b><\/strong><\/h2>\n

\ufffd\ufffd\ufffd Problem Statement:
\nGiven a string, count how many times each character appears. Treat uppercase and lowercase letters as the same.<\/p>\n

\ufffd\ufffd\ufffd Approach:
\nWe loop through each character and use an array of size 26 to store counts, treating both upper and lower case as the same index.<\/p>\n

\ufffd\ufffd\ufffd Program (C#):<\/p>\n

public class Solution
\n{
\npublic int[] CountCharacterOccurrences(string input)
\n{
\nint[] counts = new int[26];<\/p>\n

foreach (char ch in input.ToLower())
\n{
\nif (ch >= ‘a’ && ch <= ‘z’)
\n{
\ncounts[ch – ‘a’]++;
\n}
\n}<\/p>\n

return counts;
\n}
\n}<\/p>\n

\ufffd\ufffd\ufffd Explanation:
\nWe convert the string to lowercase and count characters using a fixed-size array. Each index corresponds to a letter a\u2013z.<\/p>\n

 <\/p>\n

\u2705 10. Find the Longest Word in a Sentence<\/b><\/strong><\/h2>\n

\ufffd\ufffd\ufffd Problem Statement:
\nGiven a sentence, return the longest word in it. If multiple words have the same maximum length, return the first one.<\/p>\n

\ufffd\ufffd\ufffd Approach:
\nSplit the sentence into words and check the length of each, keeping track of the longest one found so far.<\/p>\n

\ufffd\ufffd\ufffd Program (C#):<\/p>\n

public class Solution
\n{
\npublic string FindLongestWord(string sentence)
\n{
\nstring[] words = sentence.Split(‘ ‘);
\nstring longest = “”;<\/p>\n

foreach (string word in words)
\n{
\nif (word.Length > longest.Length)
\n{
\nlongest = word;
\n}
\n}<\/p>\n

return longest;
\n}
\n}<\/p>\n

\ufffd\ufffd\ufffd Explanation:
\nWe split the sentence into words and loop through them to find the one with the maximum length.<\/p>\n

\u2728 Part 3: Math & Number Logic (Problems 11\u201315)<\/b><\/strong><\/h1>\n

\u2705 11. Generate Fibonacci in Reverse<\/b><\/strong><\/h2>\n

\ufffd\ufffd\ufffd Problem Statement:
\nGenerate the first n numbers of the Fibonacci series and return them in reverse order.<\/p>\n

\ufffd\ufffd\ufffd Approach:
\nCalculate the Fibonacci numbers in a loop and store them in an array, then reverse the array before returning.<\/p>\n

\ufffd\ufffd\ufffd Program (C#):<\/p>\n

public class Solution
\n{
\npublic int[] ReverseFibonacci(int n)
\n{
\nif (n <= 0) return new int[0];
\nif (n == 1) return new int[] { 0 };<\/p>\n

int[] fib = new int[n];
\nfib[0] = 0;
\nfib[1] = 1;<\/p>\n

for (int i = 2; i < n; i++)
\n{
\nfib[i] = fib[i – 1] + fib[i – 2];
\n}<\/p>\n

Array.Reverse(fib);
\nreturn fib;
\n}
\n}<\/p>\n

\ufffd\ufffd\ufffd Explanation:
\nWe build the Fibonacci sequence iteratively and reverse it at the end using Array.Reverse.<\/p>\n

 <\/p>\n

\u2705 12. Find Zero-Sum Pairs<\/b><\/strong><\/h2>\n

\ufffd\ufffd\ufffd Problem Statement:
\nGiven an array of integers, find all unique pairs that sum to zero.<\/p>\n

\ufffd\ufffd\ufffd Approach:
\nUse nested loops to check all pairs (i, j) where i < j and arr[i] + arr[j] == 0.<\/p>\n

\ufffd\ufffd\ufffd Program (C#):<\/p>\n

public class Solution
\n{
\npublic List<(int, int)> FindZeroSumPairs(int[] nums)
\n{
\nList<(int, int)> result = new List<(int, int)>();<\/p>\n

for (int i = 0; i < nums.Length; i++)
\n{
\nfor (int j = i + 1; j < nums.Length; j++)
\n{
\nif (nums[i] + nums[j] == 0)
\n{
\nresult.Add((nums[i], nums[j]));
\n}
\n}
\n}<\/p>\n

return result;
\n}
\n}<\/p>\n

\ufffd\ufffd\ufffd Explanation:
\nWe compare each pair in the array and collect the pairs where the sum is zero. This is a brute-force approach without using extra data structures.<\/p>\n

 <\/p>\n

\u2705 13. Prime Number Checker<\/b><\/strong><\/h2>\n

\ufffd\ufffd\ufffd Problem Statement:
\nCheck whether a given number is a prime number or not.<\/p>\n

\ufffd\ufffd\ufffd Approach:
\nA number is prime if it is greater than 1 and divisible only by 1 and itself. We check for divisibility up to the square root of the number.<\/p>\n

\ufffd\ufffd\ufffd Program (C#):<\/p>\n

public class Solution
\n{
\npublic bool IsPrime(int num)
\n{
\nif (num <= 1) return false;<\/p>\n

for (int i = 2; i * i <= num; i++)
\n{
\nif (num % i == 0) return false;
\n}<\/p>\n

return true;
\n}
\n}<\/p>\n

\ufffd\ufffd\ufffd Explanation:
\nWe check divisibility from 2 up to the square root of the number. If divisible, it’s not prime.<\/p>\n

 <\/p>\n

\u2705 14. Factorial using Recursion<\/b><\/strong><\/h2>\n

\ufffd\ufffd\ufffd Problem Statement:
\nWrite a program to compute the factorial of a number using recursion.<\/p>\n

\ufffd\ufffd\ufffd Approach:
\nFactorial of n is defined as n * factorial(n-1). The base case is factorial(0) = 1.<\/p>\n

\ufffd\ufffd\ufffd Program (C#):<\/p>\n

public class Solution
\n{
\npublic int Factorial(int n)
\n{
\nif (n == 0) return 1;
\nreturn n * Factorial(n – 1);
\n}
\n}<\/p>\n

\ufffd\ufffd\ufffd Explanation:
\nThe function calls itself with a decremented value of n until it reaches 0, at which point it returns 1.<\/p>\n

 <\/p>\n

\u2705 15. Merge Two Sorted Arrays without Duplicates<\/b><\/strong><\/h2>\n

\ufffd\ufffd\ufffd Problem Statement:
\nYou are given two sorted arrays. Merge them into one sorted array without duplicates.<\/p>\n

\ufffd\ufffd\ufffd Approach:
\nUse two pointers to merge the arrays and skip duplicates while inserting into the result.<\/p>\n

\ufffd\ufffd\ufffd Program (C#):<\/p>\n

public class Solution
\n{
\npublic List<int> MergeSortedUnique(int[] arr1, int[] arr2)
\n{
\nList<int> result = new List<int>();
\nint i = 0, j = 0;<\/p>\n

while (i < arr1.Length && j < arr2.Length)
\n{
\nif (arr1[i] < arr2[j])
\n{
\nif (result.Count == 0 || result[result.Count – 1] != arr1[i])
\nresult.Add(arr1[i]);
\ni++;
\n}
\nelse if (arr1[i] > arr2[j])
\n{
\nif (result.Count == 0 || result[result.Count – 1] != arr2[j])
\nresult.Add(arr2[j]);
\nj++;
\n}
\nelse
\n{
\nif (result.Count == 0 || result[result.Count – 1] != arr1[i])
\nresult.Add(arr1[i]);
\ni++;
\nj++;
\n}
\n}<\/p>\n

while (i < arr1.Length)
\n{
\nif (result.Count == 0 || result[result.Count – 1] != arr1[i])
\nresult.Add(arr1[i]);
\ni++;
\n}<\/p>\n

while (j < arr2.Length)
\n{
\nif (result.Count == 0 || result[result.Count – 1] != arr2[j])
\nresult.Add(arr2[j]);
\nj++;
\n}<\/p>\n

return result;
\n}
\n}<\/p>\n

\ufffd\ufffd\ufffd Explanation:
\nWe use two pointers to compare values and only insert them into the result if they are not duplicates.<\/p>\n

\u2728 Part 4: Search, Sort, and Lookup (Problems 16\u201320)<\/b><\/strong><\/h1>\n

\u2705 16. Binary Search on a Sorted Array<\/b><\/strong><\/h2>\n

\ufffd\ufffd\ufffd Problem Statement:
\nGiven a sorted array and a target value, return the index of the target if found. If not found, return -1.<\/p>\n

\ufffd\ufffd\ufffd Approach:
\nUse the binary search technique: repeatedly divide the search interval in half, comparing the middle value to the target.<\/p>\n

\ufffd\ufffd\ufffd Program (C#):<\/p>\n

public class Solution
\n{
\npublic int BinarySearch(int[] nums, int target)
\n{
\nint left = 0, right = nums.Length – 1;<\/p>\n

while (left <= right)
\n{
\nint mid = left + (right – left) \/ 2;<\/p>\n

if (nums[mid] == target)
\nreturn mid;
\nelse if (nums[mid] < target)
\nleft = mid + 1;
\nelse
\nright = mid – 1;
\n}<\/p>\n

return -1;
\n}
\n}<\/p>\n

\ufffd\ufffd\ufffd Explanation:
\nWe narrow the search space by half on each iteration. This gives a time complexity of O(log n).<\/p>\n

 <\/p>\n

\u2705 17. Find First Non-Repeating Character<\/b><\/strong><\/h2>\n

\ufffd\ufffd\ufffd Problem Statement:
\nGiven a string, return the first character that does not repeat. If all characters repeat, return a space or indicator.<\/p>\n

\ufffd\ufffd\ufffd Approach:
\nUse two loops: one to count occurrences of each character, and another to find the first character with a count of 1.<\/p>\n

\ufffd\ufffd\ufffd Program (C#):<\/p>\n

public class Solution
\n{
\npublic char FirstNonRepeatingCharacter(string s)
\n{
\nint[] freq = new int[256];<\/p>\n

foreach (char c in s)
\n{
\nfreq[c]++;
\n}<\/p>\n

foreach (char c in s)
\n{
\nif (freq[c] == 1)
\nreturn c;
\n}<\/p>\n

return ‘ ‘;
\n}
\n}<\/p>\n

\ufffd\ufffd\ufffd Explanation:
\nWe count each character using an array. Then we check in original order for the first one with a count of 1.<\/p>\n

 <\/p>\n

\u2705 18. Two Sum Problem<\/b><\/strong><\/h2>\n

\ufffd\ufffd\ufffd Problem Statement:
\nGiven an array of integers and a target sum, return the indices of the two numbers that add up to the target.<\/p>\n

\ufffd\ufffd\ufffd Approach:
\nUse nested loops to check every pair of elements. If their sum equals the target, return their indices.<\/p>\n

\ufffd\ufffd\ufffd Program (C#):<\/p>\n

public class Solution
\n{
\npublic int[] TwoSum(int[] nums, int target)
\n{
\nfor (int i = 0; i < nums.Length; i++)
\n{
\nfor (int j = i + 1; j < nums.Length; j++)
\n{
\nif (nums[i] + nums[j] == target)
\nreturn new int[] { i, j };
\n}
\n}<\/p>\n

return new int[] { -1, -1 };
\n}
\n}<\/p>\n

\ufffd\ufffd\ufffd Explanation:
\nWe check each possible pair of numbers. Once we find two numbers whose sum equals the target, we return their indices.<\/p>\n

 <\/p>\n

\u2705 19. Group Anagrams<\/b><\/strong><\/h2>\n

\ufffd\ufffd\ufffd Problem Statement:
\nGiven an array of strings, group the anagrams together. Words are anagrams if they have the same characters in any order.<\/p>\n

\ufffd\ufffd\ufffd Approach:
\nSort each word and compare. Words with the same sorted value are anagrams. Group them manually into lists.<\/p>\n

\ufffd\ufffd\ufffd Program (C#):<\/p>\n

public class Solution
\n{
\npublic List<List<string>> GroupAnagrams(string[] strs)
\n{
\nList<List<string>> result = new List<List<string>>();
\nbool[] visited = new bool[strs.Length];<\/p>\n

for (int i = 0; i < strs.Length; i++)
\n{
\nif (visited[i]) continue;<\/p>\n

List<string> group = new List<string> { strs[i] };
\nvisited[i] = true;<\/p>\n

for (int j = i + 1; j < strs.Length; j++)
\n{
\nif (!visited[j] && IsAnagram(strs[i], strs[j]))
\n{
\ngroup.Add(strs[j]);
\nvisited[j] = true;
\n}
\n}<\/p>\n

result.Add(group);
\n}<\/p>\n

return result;
\n}<\/p>\n

private bool IsAnagram(string s1, string s2)
\n{
\nchar[] a = s1.ToCharArray();
\nchar[] b = s2.ToCharArray();
\nArray.Sort(a);
\nArray.Sort(b);
\nreturn new string(a) == new string(b);
\n}
\n}<\/p>\n

\ufffd\ufffd\ufffd Explanation:
\nWe check each word against others to see if they are anagrams by comparing sorted character arrays. Group matches together.<\/p>\n

 <\/p>\n

\u2705 20. Find Intersection of Two Arrays<\/b><\/strong><\/h2>\n

\ufffd\ufffd\ufffd Problem Statement:
\nGiven two arrays, return the intersection (common elements) between them without duplicates.<\/p>\n

\ufffd\ufffd\ufffd Approach:
\nUse nested loops to compare each element of the first array with the second and add only unique matches to the result.<\/p>\n

\ufffd\ufffd\ufffd Program (C#):<\/p>\n

public class Solution
\n{
\npublic List<int> Intersection(int[] nums1, int[] nums2)
\n{
\nList<int> result = new List<int>();<\/p>\n

for (int i = 0; i < nums1.Length; i++)
\n{
\nfor (int j = 0; j < nums2.Length; j++)
\n{
\nif (nums1[i] == nums2[j] && !result.Contains(nums1[i]))
\n{
\nresult.Add(nums1[i]);
\nbreak;
\n}
\n}
\n}<\/p>\n

return result;
\n}
\n}<\/p>\n

\ufffd\ufffd\ufffd Explanation:
\nWe use nested loops to find common elements and check if the result already contains the value to avoid duplicates.<\/p>\n

\u2728 Part 5: Stack, Queue, and Recursion (Problems 21\u201325)<\/b><\/strong><\/h1>\n

\u2705 21. Evaluate Reverse Polish Notation<\/b><\/strong><\/h2>\n

\ufffd\ufffd\ufffd Problem Statement:
\nGiven an array of strings representing Reverse Polish Notation (RPN), evaluate the expression and return the result.<\/p>\n

\ufffd\ufffd\ufffd Approach:
\nUse a stack to process the tokens. Push numbers onto the stack and apply operations by popping two elements when an operator is found.<\/p>\n

\ufffd\ufffd\ufffd Program (C#):<\/p>\n

public class Solution
\n{
\npublic int EvalRPN(string[] tokens)
\n{
\nStack<int> stack = new Stack<int>();<\/p>\n

foreach (string token in tokens)
\n{
\nif (int.TryParse(token, out int num))
\n{
\nstack.Push(num);
\n}
\nelse
\n{
\nint b = stack.Pop();
\nint a = stack.Pop();
\nswitch (token)
\n{
\ncase “+”: stack.Push(a + b); break;
\ncase “-“: stack.Push(a – b); break;
\ncase “*”: stack.Push(a * b); break;
\ncase “\/”: stack.Push(a \/ b); break;
\n}
\n}
\n}<\/p>\n

return stack.Pop();
\n}
\n}<\/p>\n

\ufffd\ufffd\ufffd Explanation:
\nWe use a stack to hold operands and apply operations in LIFO order. For each operator, we pop two numbers, compute the result, and push it back.<\/p>\n

 <\/p>\n

\u2705 22. Min Stack<\/b><\/strong><\/h2>\n

\ufffd\ufffd\ufffd Problem Statement:
\nDesign a stack that supports push, pop, top, and retrieving the minimum element in constant time.<\/p>\n

\ufffd\ufffd\ufffd Approach:
\nUse an additional stack to track the current minimum after each operation.<\/p>\n

\ufffd\ufffd\ufffd Program (C#):<\/p>\n

public class MinStack
\n{
\nprivate Stack<int> stack = new Stack<int>();
\nprivate Stack<int> minStack = new Stack<int>();<\/p>\n

public void Push(int val)
\n{
\nstack.Push(val);
\nif (minStack.Count == 0 || val <= minStack.Peek())
\nminStack.Push(val);
\n}<\/p>\n

public void Pop()
\n{
\nif (stack.Pop() == minStack.Peek())
\nminStack.Pop();
\n}<\/p>\n

public int Top()
\n{
\nreturn stack.Peek();
\n}<\/p>\n

public int GetMin()
\n{
\nreturn minStack.Peek();
\n}
\n}<\/p>\n

\ufffd\ufffd\ufffd Explanation:
\nWe maintain a secondary stack that tracks the minimum values. It gets updated only when a smaller or equal value is pushed.<\/p>\n

 <\/p>\n

\u2705 23. Implement Queue using Stacks<\/b><\/strong><\/h2>\n

\ufffd\ufffd\ufffd Problem Statement:
\nImplement a queue using two stacks with methods: enqueue, dequeue, and peek.<\/p>\n

\ufffd\ufffd\ufffd Approach:
\nUse two stacks. One for enqueue (input stack), and the other for dequeue (output stack). Transfer elements only when needed.<\/p>\n

\ufffd\ufffd\ufffd Program (C#):<\/p>\n

public class MyQueue
\n{
\nprivate Stack<int> input = new Stack<int>();
\nprivate Stack<int> output = new Stack<int>();<\/p>\n

public void Enqueue(int x)
\n{
\ninput.Push(x);
\n}<\/p>\n

public int Dequeue()
\n{
\nif (output.Count == 0)
\n{
\nwhile (input.Count > 0)
\n{
\noutput.Push(input.Pop());
\n}
\n}
\nreturn output.Pop();
\n}<\/p>\n

public int Peek()
\n{
\nif (output.Count == 0)
\n{
\nwhile (input.Count > 0)
\n{
\noutput.Push(input.Pop());
\n}
\n}
\nreturn output.Peek();
\n}<\/p>\n

public bool Empty()
\n{
\nreturn input.Count == 0 && output.Count == 0;
\n}
\n}<\/p>\n

\ufffd\ufffd\ufffd Explanation:
\nThis approach amortizes cost by transferring elements only when necessary, making operations efficient over time.<\/p>\n

 <\/p>\n

\u2705 24. Recursively Reverse a String<\/b><\/strong><\/h2>\n

\ufffd\ufffd\ufffd Problem Statement:
\nReverse a given string using recursion and return the result.<\/p>\n

\ufffd\ufffd\ufffd Approach:
\nUse the recursive approach: reverse(s) = reverse(substring from index 1) + first character.<\/p>\n

\ufffd\ufffd\ufffd Program (C#):<\/p>\n

public class Solution
\n{
\npublic string ReverseString(string s)
\n{
\nif (s.Length <= 1) return s;
\nreturn ReverseString(s.Substring(1)) + s[0];
\n}
\n}<\/p>\n

\ufffd\ufffd\ufffd Explanation:
\nWe recursively call the function on the substring and append the first character at the end until the string is fully reversed.<\/p>\n

 <\/p>\n

\u2705 25. Valid Parentheses (Deep Nesting)<\/b><\/strong><\/h2>\n

\ufffd\ufffd\ufffd Problem Statement:
\nGiven a string with only parentheses characters, determine if it’s valid (properly nested and matched).<\/p>\n

\ufffd\ufffd\ufffd Approach:
\nUse a stack to push opening brackets and pop when encountering the correct closing bracket.<\/p>\n

\ufffd\ufffd\ufffd Program (C#):<\/p>\n

public class Solution
\n{
\npublic bool IsValid(string s)
\n{
\nStack<char> stack = new Stack<char>();<\/p>\n

foreach (char c in s)
\n{
\nif (c == ‘(‘ || c == ‘{‘ || c == ‘[‘)
\nstack.Push(c);
\nelse
\n{
\nif (stack.Count == 0) return false;
\nchar top = stack.Pop();
\nif ((c == ‘)’ && top != ‘(‘) ||
\n(c == ‘}’ && top != ‘{‘) ||
\n(c == ‘]’ && top != ‘[‘))
\nreturn false;
\n}
\n}<\/p>\n

return stack.Count == 0;
\n}
\n}<\/p>\n

\ufffd\ufffd\ufffd Explanation:
\nThe stack helps track open brackets. Each closing bracket must match the top of the stack to be valid. Deep nesting works as long as order is preserved.<\/p>\n

\u2728 Part 6: Bonus Challenges (Problems 26\u201330)<\/b><\/strong><\/h1>\n

\u2705 26. Move Zeroes to the End<\/b><\/strong><\/h2>\n

\ufffd\ufffd\ufffd Problem Statement:
\nGiven an array, move all zeroes to the end while maintaining the relative order of the non-zero elements.<\/p>\n

\ufffd\ufffd\ufffd Approach:
\nUse two pointers: one for current element, another for tracking non-zero placement index. Swap when needed.<\/p>\n

\ufffd\ufffd\ufffd Program (C#):<\/p>\n

public class Solution
\n{
\npublic void MoveZeroes(int[] nums)
\n{
\nint index = 0;<\/p>\n

for (int i = 0; i < nums.Length; i++)
\n{
\nif (nums[i] != 0)
\n{
\nnums[index++] = nums[i];
\n}
\n}<\/p>\n

while (index < nums.Length)
\n{
\nnums[index++] = 0;
\n}
\n}
\n}<\/p>\n

\ufffd\ufffd\ufffd Explanation:
\nWe shift all non-zero elements to the front and then fill the remaining array with zeroes.<\/p>\n

 <\/p>\n

\u2705 27. Find Duplicates in an Array<\/b><\/strong><\/h2>\n

\ufffd\ufffd\ufffd Problem Statement:
\nGiven an array of integers, find all elements that appear more than once.<\/p>\n

\ufffd\ufffd\ufffd Approach:
\nUse a nested loop to compare each element with the rest, and add to the result list if not already added.<\/p>\n

\ufffd\ufffd\ufffd Program (C#):<\/p>\n

public class Solution
\n{
\npublic List<int> FindDuplicates(int[] nums)
\n{
\nList<int> duplicates = new List<int>();<\/p>\n

for (int i = 0; i < nums.Length; i++)
\n{
\nfor (int j = i + 1; j < nums.Length; j++)
\n{
\nif (nums[i] == nums[j] && !duplicates.Contains(nums[i]))
\n{
\nduplicates.Add(nums[i]);
\nbreak;
\n}
\n}
\n}<\/p>\n

return duplicates;
\n}
\n}<\/p>\n

\ufffd\ufffd\ufffd Explanation:
\nEach element is compared to every other. When a duplicate is found, it’s added to a result list only once.<\/p>\n

 <\/p>\n

\u2705 28. Rotate Matrix 90 Degrees<\/b><\/strong><\/h2>\n

\ufffd\ufffd\ufffd Problem Statement:
\nGiven an NxN 2D matrix, rotate it 90 degrees clockwise in place.<\/p>\n

\ufffd\ufffd\ufffd Approach:
\nFirst transpose the matrix (swap rows with columns), then reverse each row.<\/p>\n

\ufffd\ufffd\ufffd Program (C#):<\/p>\n

public class Solution
\n{
\npublic void Rotate(int[][] matrix)
\n{
\nint n = matrix.Length;<\/p>\n

\/\/ Transpose
\nfor (int i = 0; i < n; i++)
\n{
\nfor (int j = i + 1; j < n; j++)
\n{
\nint temp = matrix[i][j];
\nmatrix[i][j] = matrix[j][i];
\nmatrix[j][i] = temp;
\n}
\n}<\/p>\n

\/\/ Reverse each row
\nfor (int i = 0; i < n; i++)
\n{
\nArray.Reverse(matrix[i]);
\n}
\n}
\n}<\/p>\n

\ufffd\ufffd\ufffd Explanation:
\nTransposing flips the matrix diagonally. Reversing each row completes the 90-degree clockwise rotation.<\/p>\n

 <\/p>\n

\u2705 29. Pascal\u2019s Triangle<\/b><\/strong><\/h2>\n

\ufffd\ufffd\ufffd Problem Statement:
\nGiven a number of rows, generate Pascal\u2019s Triangle up to that row.<\/p>\n

\ufffd\ufffd\ufffd Approach:
\nBuild each row based on the previous row. The first and last values of each row are 1. Middle values are sum of two numbers above.<\/p>\n

\ufffd\ufffd\ufffd Program (C#):<\/p>\n

public class Solution
\n{
\npublic List<List<int>> GeneratePascalTriangle(int numRows)
\n{
\nList<List<int>> triangle = new List<List<int>>();<\/p>\n

for (int i = 0; i < numRows; i++)
\n{
\nList<int> row = new List<int>();
\nfor (int j = 0; j <= i; j++)
\n{
\nif (j == 0 || j == i)
\nrow.Add(1);
\nelse
\nrow.Add(triangle[i – 1][j – 1] + triangle[i – 1][j]);
\n}
\ntriangle.Add(row);
\n}<\/p>\n

return triangle;
\n}
\n}<\/p>\n

\ufffd\ufffd\ufffd Explanation:
\nEach row is formed by adding adjacent values from the row above. The first and last values are always 1.<\/p>\n

 <\/p>\n

\u2705 30. Maximum Subarray (Kadane\u2019s Algorithm)<\/b><\/strong><\/h2>\n

\ufffd\ufffd\ufffd Problem Statement:
\nFind the contiguous subarray within an array which has the largest sum.<\/p>\n

\ufffd\ufffd\ufffd Approach:
\nUse Kadane\u2019s algorithm to track current max and global max as we iterate through the array.<\/p>\n

\ufffd\ufffd\ufffd Program (C#):<\/p>\n

public class Solution
\n{
\npublic int MaxSubArray(int[] nums)
\n{
\nint maxSoFar = nums[0], maxEndingHere = nums[0];<\/p>\n

for (int i = 1; i < nums.Length; i++)
\n{
\nmaxEndingHere = Math.Max(nums[i], maxEndingHere + nums[i]);
\nmaxSoFar = Math.Max(maxSoFar, maxEndingHere);
\n}<\/p>\n

return maxSoFar;
\n}
\n}<\/p>\n

\ufffd\ufffd\ufffd Explanation:
\nAt each step, we calculate whether to include the current element in the existing subarray or start a new one.<\/p>\n

 <\/p>\n","protected":false},"excerpt":{"rendered":"

\u2728 Part 1: Linked Lists & Arrays (Problems 1\u20135) \u2705 1. Reverse a Linked List \ufffd\ufffd\ufffd Problem Statement: You are given the head of a singly linked list. You need to reverse the list so that the last node becomes the first, and each node points to the previous one. \ufffd\ufffd\ufffd Approach: We\u2019ll use three […]<\/p>\n","protected":false},"author":43,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_uag_custom_page_level_css":"","footnotes":""},"categories":[1],"tags":[],"class_list":["post-943","post","type-post","status-publish","format-standard","hentry","category-blog"],"uagb_featured_image_src":{"full":false,"thumbnail":false,"medium":false,"medium_large":false,"large":false,"1536x1536":false,"2048x2048":false},"uagb_author_info":{"display_name":"Himanshu Namdeo","author_link":"https:\/\/debuggersspace.com\/author\/admin\/"},"uagb_comment_info":0,"uagb_excerpt":"\u2728 Part 1: Linked Lists & Arrays (Problems 1\u20135) \u2705 1. Reverse a Linked List \ufffd\ufffd\ufffd Problem Statement: You are given the head of a singly linked list. You need to reverse the list so that the last node becomes the first, and each node points to the previous one. \ufffd\ufffd\ufffd Approach: We\u2019ll use three…","_links":{"self":[{"href":"https:\/\/debuggersspace.com\/index.php\/wp-json\/wp\/v2\/posts\/943"}],"collection":[{"href":"https:\/\/debuggersspace.com\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/debuggersspace.com\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/debuggersspace.com\/index.php\/wp-json\/wp\/v2\/users\/43"}],"replies":[{"embeddable":true,"href":"https:\/\/debuggersspace.com\/index.php\/wp-json\/wp\/v2\/comments?post=943"}],"version-history":[{"count":1,"href":"https:\/\/debuggersspace.com\/index.php\/wp-json\/wp\/v2\/posts\/943\/revisions"}],"predecessor-version":[{"id":944,"href":"https:\/\/debuggersspace.com\/index.php\/wp-json\/wp\/v2\/posts\/943\/revisions\/944"}],"wp:attachment":[{"href":"https:\/\/debuggersspace.com\/index.php\/wp-json\/wp\/v2\/media?parent=943"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/debuggersspace.com\/index.php\/wp-json\/wp\/v2\/categories?post=943"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/debuggersspace.com\/index.php\/wp-json\/wp\/v2\/tags?post=943"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}