# Coding Interviews: Greedy Algorithms

Given an array of intervals where intervals[i] = [starti, endi], merge all overlapping intervals, and return *an array of the non-overlapping intervals that cover all the intervals in the input*.

You are given an integer array nums. You are initially positioned at the array's **first index**, and each element in the array represents your maximum jump length at that position.

Return true* if you can reach the last index, or *false* otherwise*.

You are given an array of CPU tasks, each represented by letters A to Z, and a cooling time, n. Each cycle or interval allows the completion of one task. Tasks can be completed in any order, but there's a constraint: **identical** tasks must be separated by at least n intervals due to cooling time.

Return the *minimum number of intervals* required to complete all tasks.

Given an array nums with n integers, your task is to check if it could become non-decreasing by modifying **at most one element**.

We define an array is non-decreasing if nums[i] <= nums[i + 1] holds for every i (**0-based**) such that (0 <= i <= n - 2).

Given a positive integer n, return a string representing the smallest positive integer such that the product of its digits is equal to n, or "-1" if no such number exists.

You are given an integer n which is the length of a **0-indexed** array nums, and a **0-indexed** 2D-array ranges, which is a list of sub-ranges of nums (sub-ranges may **overlap**).

Each row ranges[i] has exactly 2 cells:

ranges[i][0], which shows the start of the ith range (inclusive)

ranges[i][1], which shows the end of the ith range (inclusive)

These ranges cover some cells of nums and leave some cells uncovered. Your task is to find all of the **uncovered **ranges with **maximal** length.

Return *a 2D-array *answer* of the uncovered ranges, ***sorted*** by the starting point in ***ascending order***.*

By all of the **uncovered** ranges with **maximal** length, we mean satisfying two conditions:

Each uncovered cell should belong to **exactly** one sub-range

There should **not exist** two ranges (l1, r1) and (l2, r2) such that r1 + 1 = l2