abanoub-ashraf/coding-challenge-coach

Coding Challenge Coach

Your personal coding interview coach. Practice algorithm problems with progressive hints, time management, and detailed solution analysis.

When to Use This Skill

• Practicing LeetCode/HackerRank problems
• Preparing for live coding interviews
• Learning algorithm patterns
• Improving problem-solving speed

Essential Algorithm Patterns

Pattern 1: Two Pointers

When to use: Sorted arrays, finding pairs, palindromes

// Two Sum II (sorted array)
func twoSum(_ numbers: [Int], _ target: Int) -> [Int] {
    var left = 0
    var right = numbers.count - 1

    while left < right {
        let sum = numbers[left] + numbers[right]
        if sum == target {
            return [left + 1, right + 1]
        } else if sum < target {
            left += 1
        } else {
            right -= 1
        }
    }
    return []
}
// Time: O(n), Space: O(1)

Pattern 2: Sliding Window

When to use: Contiguous subarrays, substrings

// Longest Substring Without Repeating Characters
func lengthOfLongestSubstring(_ s: String) -> Int {
    let chars = Array(s)
    var seen: [Character: Int] = [:]
    var maxLength = 0
    var windowStart = 0

    for (windowEnd, char) in chars.enumerated() {
        if let lastSeen = seen[char], lastSeen >= windowStart {
            windowStart = lastSeen + 1
        }
        seen[char] = windowEnd
        maxLength = max(maxLength, windowEnd - windowStart + 1)
    }
    return maxLength
}
// Time: O(n), Space: O(min(n, alphabet_size))

Pattern 3: Fast & Slow Pointers

When to use: Linked lists, cycle detection

// Linked List Cycle Detection
func hasCycle(_ head: ListNode?) -> Bool {
    var slow = head
    var fast = head

    while fast != nil && fast?.next != nil {
        slow = slow?.next
        fast = fast?.next?.next
        if slow === fast { return true }
    }
    return false
}
// Time: O(n), Space: O(1)

Pattern 4: Binary Search

// Search in Rotated Sorted Array
func search(_ nums: [Int], _ target: Int) -> Int {
    var left = 0, right = nums.count - 1

    while left <= right {
        let mid = left + (right - left) / 2
        if nums[mid] == target { return mid }

        if nums[left] <= nums[mid] {
            if nums[left] <= target && target < nums[mid] {
                right = mid - 1
            } else {
                left = mid + 1
            }
        } else {
            if nums[mid] < target && target <= nums[right] {
                left = mid + 1
            } else {
                right = mid - 1
            }
        }
    }
    return -1
}

Pattern 5: Dynamic Programming

The DP Framework:

1. Define the state: What does dp[i] represent?
2. Find the recurrence relation
3. Set base cases
4. Determine traversal order

// Coin Change
func coinChange(_ coins: [Int], _ amount: Int) -> Int {
    var dp = Array(repeating: amount + 1, count: amount + 1)
    dp[0] = 0

    for i in 1...amount {
        for coin in coins {
            if coin <= i {
                dp[i] = min(dp[i], dp[i - coin] + 1)
            }
        }
    }
    return dp[amount] > amount ? -1 : dp[amount]
}
// Time: O(amount * coins), Space: O(amount)

iOS-Specific Algorithm Applications

LRU Cache (Image Caching)

class LRUCache<Key: Hashable, Value> {
    private let capacity: Int
    private var cache: [Key: Value] = [:]
    private var order: [Key] = []

    init(capacity: Int) {
        self.capacity = capacity
    }

    func get(_ key: Key) -> Value? {
        guard let value = cache[key] else { return nil }
        order.removeAll { $0 == key }
        order.append(key)
        return value
    }

    func put(_ key: Key, _ value: Value) {
        if cache[key] != nil {
            order.removeAll { $0 == key }
        } else if cache.count >= capacity {
            let lru = order.removeFirst()
            cache.removeValue(forKey: lru)
        }
        cache[key] = value
        order.append(key)
    }
}

Trie for Autocomplete

class Trie {
    private class TrieNode {
        var children: [Character: TrieNode] = [:]
        var isEndOfWord = false
    }

    private let root = TrieNode()

    func insert(_ word: String) {
        var node = root
        for char in word {
            if node.children[char] == nil {
                node.children[char] = TrieNode()
            }
            node = node.children[char]!
        }
        node.isEndOfWord = true
    }

    func search(_ word: String) -> Bool {
        guard let node = findNode(word) else { return false }
        return node.isEndOfWord
    }

    private func findNode(_ prefix: String) -> TrieNode? {
        var node = root
        for char in prefix {
            guard let next = node.children[char] else { return nil }
            node = next
        }
        return node
    }
}

Hint System

When practicing, I provide progressive hints:

Level 1: "Think about what data structure would help here" Level 2: "This is a sliding window problem" Level 3: "Keep track of seen characters in a hashmap" Level 4: Step-by-step pseudocode Level 5: Full solution with explanation

Big-O Cheat Sheet

| Complexity | Name | Example | |------------|------|---------| | O(1) | Constant | Array access | | O(log n) | Logarithmic | Binary search | | O(n) | Linear | Single loop | | O(n log n) | Linearithmic | Efficient sorting | | O(n²) | Quadratic | Nested loops | | O(2ⁿ) | Exponential | Recursive subsets |

How to Use

Ask me to:

• "Give me a medium Two Pointers problem"
• "Start a 45-minute mock coding interview"
• "Hint me on solving LRU Cache"
• "Explain the sliding window pattern"
• "Review my solution for time complexity"