Universal Helper Functions for Interviews (TypeScript)

These functions will help solve arrays, strings, graphs, trees, and DP problems with minimal effort.

1️⃣ Forward & Backward Traversal

Used for prefix sums, sliding window, and DP problems.

function moveForward<T>(arr: T[], callback: (val: T, i: number) => void): void {

    for (let i = 0; i < arr.length; i++) callback(arr[i], i);

}

function moveBackward<T>(arr: T[], callback: (val: T, i: number) => void): void {

    for (let i = arr.length - 1; i >= 0; i--) callback(arr[i], i);

}

✔ Usage:

Trapping Rain Water (prefix/suffix max)

Kadane’s Algorithm (max subarray sum)

Stock Buy/Sell Problem

2️⃣ Two-Pointer Expansion (Palindromes, Intervals)

Used for finding palindromes, expanding subarrays, and binary search-like problems.

function expandFromCenter(s: string, left: number, right: number): string {

    while (left >= 0 && right < s.length && s[left] === s[right]) {

        left--;

        right++;

    }

    return s.substring(left + 1, right);

}

✔ Usage:

Longest Palindromic Substring

Valid Parentheses Expansion

Expanding Intervals

3️⃣ Sliding Window

Used for fixed-size or variable-size window problems like substrings, min/max subarrays.

function slidingWindow(arr: number[], k: number, callback: (window: number[], start: number) => void): void {

    let window: number[] = [];

    for (let i = 0; i < arr.length; i++) {

        window.push(arr[i]);

        if (window.length > k) window.shift();

        if (window.length === k) callback(window, i - k + 1);

    }

}

✔ Usage:

Longest Substring Without Repeating Characters

Find Maximum in Every Window of Size K

Minimum Window Substring

4️⃣ Frequency Map (Counting Occurrences)

Used for anagrams, character frequency, and hashmap-based problems.

function frequencyMap<T>(arr: T[]): Map<T, number> {

    let freq = new Map<T, number>();

    arr.forEach((val) => freq.set(val, (freq.get(val) || 0) + 1));

    return freq;

}

✔ Usage:

Group Anagrams

Find Majority Element

Check if Two Strings are Permutations

5️⃣ Binary Search (Optimized Search)

Used for searching in sorted arrays, lower/upper bounds.

function binarySearch(arr: number[], target: number): number {

    let left = 0, right = arr.length - 1;

    while (left <= right) {

        let mid = Math.floor((left + right) / 2);

        if (arr[mid] === target) return mid;

        if (arr[mid] < target) left = mid + 1;

        else right = mid - 1;

    }

    return -1;

}

✔ Usage:

Finding an element in a sorted array

Search in Rotated Sorted Array

Lower Bound / Upper Bound Problems

6️⃣ Recursion Helper (For Trees & Backtracking)

Used for tree traversal, backtracking, and DFS-like problems.

function recurse<T>(arr: T[], index: number, callback: (val: T, i: number) => void): void {

    if (index >= arr.length) return;

    callback(arr[index], index);

    recurse(arr, index + 1, callback);

}

✔ Usage:

Binary Tree Traversal

N-Queens & Sudoku Solver

Subsets & Combinations

7️⃣ Graph Traversal (DFS & BFS)

Used for graph problems, shortest paths, cycle detection.

DFS (Depth-First Search)

function dfs(graph: Map<number, number[]>, node: number, visited: Set<number>): void {

    if (visited.has(node)) return;

    visited.add(node);

    for (let neighbor of (graph.get(node) || [])) {

        dfs(graph, neighbor, visited);

    }

}

BFS (Breadth-First Search) 

function bfs(graph: Map<number, number[]>, start: number): void {

    let queue: number[] = [start];

    let visited = new Set<number>([start]);

    

    while (queue.length > 0) {

        let node = queue.shift()!;

        for (let neighbor of (graph.get(node) || [])) {

            if (!visited.has(neighbor)) {

                visited.add(neighbor);

                queue.push(neighbor);

            }

        }

    }

}

✔ Usage:

Shortest Path in Graphs (BFS)

Cycle Detection (DFS)

Connected Components / Islands

8️⃣ Bit Manipulation

Used for XOR tricks, finding unique numbers, and optimization.

function xorAll(arr: number[]): number {

    return arr.reduce((acc, num) => acc ^ num, 0);

}

✔ Usage:

Finding Missing Number in an Array

Single Number (XOR property)

Optimized Bitwise Tricks

9️⃣ Matrix Traversal (2D Arrays)

Used for grid-based problems like shortest paths, island counting.

function traverseMatrix(matrix: number[][], callback: (val: number, r: number, c: number) => void): void {

    for (let r = 0; r < matrix.length; r++) {

        for (let c = 0; c < matrix[0].length; c++) {

            callback(matrix[r][c], r, c);

        }

    }

}

✔ Usage:

Number of Islands (DFS/BFS)

Flood Fill Algorithm

Word Search in a Grid

🔟 Sorting Helper (For Custom Sorting)

Used for sorting objects, strings, or custom comparator problems.

function sortBy<T>(arr: T[], compareFn: (a: T, b: T) => number): T[] {

    return [...arr].sort(compareFn);

}

✔ Usage:

Sort by Frequency, Value, or Custom Order

K Closest Points to Origin

Sorting Strings Lexicographically

📌 Summary: Why These Functions Are Powerful

✅ Reusability → No need to write basic loops again.

✅ Problem Solving Speed → Focus on logic, not implementation details.

✅ Works for All Data Structures → Arrays, Strings, Trees, Graphs, etc.

✅ Interview Readiness → These helpers cover 90% of coding problems.