💥 Compilation Error: (Cannot compile, cannot run)
Occurs when the code has syntax issues, preventing it from being compiled. Common examples include missing semicolons, mismatched parentheses, or undeclared variables.
Example: int x = ;

⚡️ Runtime Error: (Compiles but cannot run, compilation comes before code execution or running)
Happens while the program is running. It usually occurs due to illegal operations like division by zero, accessing invalid memory, or infinite loops.
Example: int x = 5 / 0;

🔍 Logical Error: (Code compiles and runs but won't result a correct output)
Occurs when the code runs without crashing, but it produces incorrect results due to flawed logic or assumptions. It can be tricky to spot as the program compiles and runs fine.
Example: int a = 5; int b = 2; cout << a - b; (Expecting multiplication but using subtraction)

void insertion_sort(int arr[], int size) {
    int temp, i, j;
    for (i = 0; i < size; i++) {
        temp = arr[i];
        j = i;
        while (j > 0 && arr[j-1] > temp) {
            arr[j] = arr[j - 1];
            j--;
        }
        arr[j] = temp;
    }
}

void bubble_sort(int arr[], int size) {
    for (int i = 0; i < size; i++) {
        for (int j = i + 1; j < size; j++) {
            if (arr[i] > arr[j]) {
                swap(arr[i], arr[j]);
            }
        }
    }
    return;
}

void bubbleSortOptimized(int arr[], int size) {
    for (int i = 0; i < size - 1; i++) {
        bool swapped = false;
        for (int j = 0; j < size - 1 - i; j++) {
            if (arr[j] > arr[j + 1]) {
                swap(arr[j], arr[j + 1]);
                swapped = true;
            }
        }
        if (!swapped) break;
    }
}

void selection_sort(int arr[], int size) {
    int min_index;
    for (int i = 0; i < size; i++) {
        min_index = i;
        for (int j = i + 1; j < size; j++) {
            if (arr[j] < arr[min_index]) {
                min_index = j;
            }
        }
            swap(arr[i], arr[min_index;
    }
}

void bubbleSortOptimized(int arr[], int n) {
    for (int i = 0; i < n - 1; i++) {
        bool swapped = false;
        for (int j = 0; j < n - 1 - i; j++) {
            if (arr[j] > arr[j + 1]) {
                swap(arr[j], arr[j + 1]);
                swapped = true;
            }
        }
        if (!swapped) break;
    }
}

“A year from now you may wish you had
started today”

class Solution:
    def searchRange(self, nums: List[int], target: int) -> List[int]:
        def first():
            l, r = 0, len(nums)-1
            first = -1 
            while l <= r:
                mid = (l+r)//2
                if nums[mid] == target:
                    first = mid
                    r = mid - 1
                elif nums[mid] < target:
                    l = mid + 1
                else:
                    r = mid - 1
            return first
        def last():
            l, r = 0, len(nums)-1
            last = -1 
            while l <= r:
                mid = (l+r)//2
                if nums[mid] == target:
                    last = mid
                    l = mid + 1
                elif nums[mid] < target:
                    l = mid + 1
                else:
                    r = mid - 1
            return last

        f = first()
        if f == - 1: return [-1, -1]
        la = last()
        return [f, la]

class Solution:
    def searchRange(self, nums: List[int], target: int) -> List[int]:
        def lower_bound():
            l, r = 0, len(nums)-1
            ans = len(nums)
            while l <= r:
                mid = (l+r)//2
                if nums[mid] >= target:
                    ans = mid
                    r = mid - 1
                else:
                    l = mid + 1
            return ans
        def upper_bound():
            l, r = 0, len(nums)-1
            ans = len(nums)
            while l <= r:
                mid = (l+r)//2
                if nums[mid] > target:
                    ans = mid
                    r = mid - 1
                else:
                    l = mid + 1
            return ans
        
        lb = lower_bound()
        up = upper_bound() - 1
        if lb <= up:
            return [lb, up]
        return [-1, -1]

class Solution:
    def searchRange(self, nums: List[int], target: int) -> List[int]:
        lb = bisect.bisect_left(nums, target)
        if lb >= len(nums) or nums[lb] != target:
            return [-1, -1]
        ub = bisect.bisect_right(nums, target)
        return [lb, ub-1]
    

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        auto lb = lower_bound(nums.begin(), nums.end(), target) - nums.begin();
        if (lb >= nums.size() || nums[lb] != target)
            return {-1, -1};
        auto ub = upper_bound(nums.begin(), nums.end(), target) - nums.begin();
        return {(int)lb, (int)ub-1};
    }
};

class Solution:
    def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:
        row = len(matrix)
        col = len(matrix[0])
        l, r = 0, (row * col) - 1
        while l <= r:
            mid = (l+r)//2
            # i = mid // col
            # j = mid % col
            i, j = divmod(mid, col) # one liner for the above
            if matrix[i][j] == target:
                return True
            elif target >= matrix[i][j]:
                l = mid + 1
            else:
                r = mid - 1
        return False

Time complexity = O(n×log(maxDays)) ; Space complexity = O(1)

class Solution:
    def minDays(self, bloomDay: List[int], m: int, k: int) -> int:
        max_days = max(bloomDay)
        min_days = -1
        L, R = 0, max_days
        while L <= R:
            mid = (L+R)//2
            count = 0
            m_count = 0
            for bloom in bloomDay:
                if mid >= bloom:
                    count += 1
                    if count >= k:
                        m_count += 1
                        count = 0
                else:
                    count = 0
            if m_count >= m:
                min_days = mid
                R = mid - 1  
            else:
                L = mid + 1
            
        return min_days