Universal Helper Functions for Interviews (C#)
namespace Logic
{
public class Traversal
{
public void MoveForward<T>(T[] arr, Action<T, int> callback)
{
for (int i = 0; i < arr.Length; i++) callback(arr[i], i);
}
public void MoveBackward<T>(T[] arr, Action<T, int> callback)
{
for (int i = arr.Length - 1; i >= 0; i--) callback(arr[i], i);
}
}
public class Expansion
{
public string ExpandFromCenter(string s, int left, int right)
{
while (left >= 0 && right < s.Length && s[left] == s[right])
{
left--;
right++;
}
return s.Substring(left + 1, right - left - 1);
}
}
public class Sliding
{
public void SlidingWindow(int[] arr, int k, Action<int[], int> callback)
{
List<int> window = new();
for (int i = 0; i < arr.Length; i++)
{
window.Add(arr[i]);
if (window.Count > k) window.RemoveAt(0);
if (window.Count == k) callback(window.ToArray(), i - k + 1);
}
}
}
public class FrequencyMap
{
public Dictionary<T, int> GetFrequencyMap<T>(T[] arr)
{
Dictionary<T, int> map = new();
foreach (var item in arr)
{
if (map.ContainsKey(item)) map[item]++;
else map[item] = 1;
}
return map;
}
}
public class Searching
{
public int BinarySearch(int[] arr, int target)
{
int left = 0, right = arr.Length - 1;
while (left <= right)
{
int mid = left + (right - left) / 2;
if (arr[mid] == target) return mid;
if (arr[mid] < target) left = mid + 1;
else right = mid - 1;
}
return -1;
}
}
public class Recursion
{
void Recurse<T>(T[] arr, int index, Action<T, int> callback)
{
if (index >= arr.Length) return;
callback(arr[index], index);
Recurse(arr, index + 1, callback);
}
public int Factorial(int n)
{
if (n == 0) return 1;
return n * Factorial(n - 1);
}
}
public class Graph
{
public void BFS(Dictionary<int, List<int>> graph, int start)
{
var queue = new Queue<int>();
var visited = new HashSet<int> { start };
queue.Enqueue(start);
while (queue.Count > 0)
{
int node = queue.Dequeue();
foreach (var neighbor in graph.GetValueOrDefault(node, new List<int>()))
{
if (!visited.Contains(neighbor))
{
visited.Add(neighbor);
queue.Enqueue(neighbor);
}
}
}
}
public void BFS<T>(T[] arr, Action<T, int> callback)
{
Queue<T> queue = new();
for (int i = 0; i < arr.Length; i++)
{
queue.Enqueue(arr[i]);
while (queue.Count > 0)
{
T node = queue.Dequeue();
callback(node, i);
}
}
}
public void DFS(Dictionary<int, List<int>> graph, int node, HashSet<int> visited)
{
if (visited.Contains(node)) return;
visited.Add(node);
foreach (var neighbor in graph.GetValueOrDefault(node, new List<int>()))
{
DFS(graph, neighbor, visited);
}
}
public void DFS<T>(T[] arr, Action<T, int> callback)
{
Stack<T> stack = new();
for (int i = 0; i < arr.Length; i++)
{
stack.Push(arr[i]);
while (stack.Count > 0)
{
T node = stack.Pop();
callback(node, i);
}
}
}
}
public class BitManipulation
{
public int XorAll(int[] arr)
{
return arr.Aggregate(0, (acc, num) => acc ^ num);
}
public int CountBits(int n)
{
int count = 0;
while (n > 0)
{
count += n & 1;
n >>= 1;
}
return count;
}
}
public class Matrix
{
public void TraverseMatrix(int[,] matrix, Action<int, int, int> callback)
{
int rows = matrix.GetLength(0), cols = matrix.GetLength(1);
for (int r = 0; r < rows; r++)
{
for (int c = 0; c < cols; c++)
{
callback(matrix[r, c], r, c);
}
}
}
public void RotateMatrix(int[][] matrix)
{
int n = matrix.Length;
for (int i = 0; i < n / 2; i++)
{
for (int j = i; j < n - i - 1; j++)
{
int temp = matrix[i][j];
matrix[i][j] = matrix[n - 1 - j][i];
matrix[n - 1 - j][i] = matrix[n - 1 - i][n - 1 - j];
matrix[n - 1 - i][n - 1 - j] = matrix[j][n - 1 - i];
matrix[j][n - 1 - i] = temp;
}
}
}
}
public class Sorting
{
T[] SortBy<T>(T[] arr, Comparison<T> compareFn)
{
T[] sortedArr = (T[])arr.Clone();
Array.Sort(sortedArr, compareFn);
return sortedArr;
}
}
}
Comments
Post a Comment