# Coding Interviews: Greedy Algorithms

You are given a **0-indexed** array of integers nums of length n. You are initially positioned at nums[0].

Each element nums[i] represents the maximum length of a forward jump from index i. In other words, if you are at nums[i], you can jump to any nums[i + j] where:

0 <= j <= nums[i] and

i + j < n

Return *the minimum number of jumps to reach *nums[n - 1]. The test cases are generated such that you can reach nums[n - 1].

You are given an integer array prices where prices[i] is the price of a given stock on the ith day.

On each day, you may decide to buy and/or sell the stock. You can only hold **at most one** share of the stock at any time. However, you can buy it then immediately sell it on the **same day**.

Find and return *the ***maximum*** profit you can achieve*.

Given a string s, remove duplicate letters so that every letter appears once and only once. You must make sure your result is **the smallest in lexicographical order **among all possible results.

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

Given an integer array nums and an integer k, split nums into k non-empty subarrays such that the largest sum of any subarray is **minimized**.

Return *the minimized largest sum of the split*.

A **subarray** is a contiguous part of the array.