Coding Puzzle Interview Playbook

There are n children standing in a line, each assigned a specific rating value. You need to distribute candies to these children under two conditions: 1. Every child must receive at least one candy. 2. Children with a higher rating than their immediate neighbors (left or right) must receive more candies than those neighbors. Write a function to calculate the minimum total number of candies required to satisfy these conditions. Constraints: - 1 <= n <= 2 * 10^4 - 0 <= ratings[i] <= 2 * 10^4

Given an array of strings `words`, find all possible character frequency distributions of its shortest common supersequences (SCS). A shortest common supersequence is a string of minimum length that contains each string in `words` as a subsequence. Two supersequences are considered identical for this problem if one is a permutation of the other (i.e., they have the same character counts). Return a 2D array `freqs` where each `freqs[i]` is an integer array of size 26 representing the frequency of each lowercase English letter ('a'-'z') for a unique SCS multiset. You may return the frequency arrays in any order. Constraints: - `1 <= words.length <= 8` - `1 <= words[i].length <= 12` - `words[i]` consists of lowercase English letters.

Given an input string `s` and a pattern `p`, implement a function to determine if `s` matches `p` exactly. The pattern supports the following special characters: - `.` matches any single character. - `*` matches zero or more of the preceding element. The matching should cover the entire input string (not partial). Example 1: Input: s = "aa", p = "a*" Output: true Example 2: Input: s = "ab", p = ".*" Output: true Constraints: - 1 <= s.length <= 20 - 1 <= p.length <= 30 - s contains only lowercase English letters. - p contains lowercase English letters, '.', and '*'. - It is guaranteed for each appearance of the character '*', there will be a previous valid character to match.

You are managing a GPU cluster that uses a credit-based system for job execution. You start with `initial_credits` and a `max_capacity`. Credits regenerate at a constant `regeneration_rate` per unit of time. You are given a list of `tasks`, where each task is `[timestamp, cost]`. A task can only be executed if your current credit balance is at least equal to the task's cost at that timestamp. If you choose to execute a task, the cost is immediately deducted from your balance. If you cannot afford a task, you may choose to 'undo' a previously executed task to reclaim its credits (though the time spent is not recovered). Determine the maximum number of tasks you can complete given the task schedule. Assume for this optimization that reclaiming credits from a past task ignores the capacity limit for the reclaimed amount.

Given an array `prices` where `prices[i]` is the price of a given stock on the i-th day, design an algorithm to find the maximum profit you can achieve with at most two transactions. You may not engage in multiple transactions simultaneously (i.e., you must sell the stock before you buy again). Your solution should ideally run in linear time and use constant extra space.

Given two sorted arrays `nums1` and `nums2` of size `m` and `n` respectively, return the median of the two sorted arrays. The overall run time complexity must be $O(\log (m+n))$. Example 1: Input: nums1 = [1,3], nums2 = [2] Output: 2.00000 Explanation: merged array = [1,2,3] and median is 2. Example 2: Input: nums1 = [1,2], nums2 = [3,4] Output: 2.50000 Explanation: merged array = [1,2,3,4] and median is (2 + 3) / 2 = 2.5. Constraints: - `nums1.length == m` - `nums2.length == n` - `0 <= m <= 1000` - `0 <= n <= 1000` - `1 <= m + n <= 2000` - `-10^6 <= nums1[i], nums2[i] <= 10^6`

Given an array of non-negative integers representing an elevation map where the width of each bar is 1, compute how much water it can trap after raining. Example: Input: height = [0,1,0,2,1,0,1,3,2,1,2,1] Output: 6 Constraints: - n == height.length - 1 <= n <= 2 * 10^4 - 0 <= height[i] <= 10^5

Given an array of intervals where intervals[i] = [start_i, end_i], merge all overlapping intervals and return an array of the non-overlapping intervals that cover all the intervals in the input. Two intervals [a, b] and [c, d] overlap if there is any point shared between them (e.g., [1, 2] and [2, 3] overlap). Constraints: - 1 <= intervals.length <= 10^4 - intervals[i].length == 2 - 0 <= start_i <= end_i <= 10^4

You are given an $n \times n$ binary matrix `grid`. You are permitted to change at most one `0` to a `1`. An island is defined as a group of `1`s connected 4-directionally (up, down, left, right). Find and return the size of the largest possible island that can be formed after performing this operation at most once. Constraints: - $n == grid.length$ - $n == grid[i].length$ - $1 \le n \le 500$ - $grid[i][j]$ is either $0$ or $1$.

You are given an integer array `instructions`. You need to build a sorted collection by inserting elements from `instructions` one by one in the given order. The cost of inserting an element `instructions[i]` into the current collection is defined as the minimum of: 1. The number of elements currently in the collection that are strictly less than `instructions[i]`. 2. The number of elements currently in the collection that are strictly greater than `instructions[i]`. Calculate the total cost of inserting all elements from `instructions`. Since the total cost can be very large, return the result modulo $10^9 + 7$. Constraints: - `1 <= instructions.length <= 10^5` - `1 <= instructions[i] <= 10^5`

You are given an array of $k$ linked-lists `lists`, where each linked-list is sorted in ascending order. Your task is to merge all the linked-lists into a single sorted linked-list and return its head. Example: Input: `lists = [[1,4,5],[1,3,4],[2,6]]` Output: `[1,1,2,3,4,4,5,6]` Constraints: - `k == lists.length` - `0 <= k <= 10^4` - `0 <= lists[i].length <= 500` - `-10^4 <= lists[i][j] <= 10^4` - The total number of nodes in all lists does not exceed $10^4$.

You are given an integer array `prices` where `prices[i]` is the price of a given stock on the $i^{th}$ day, and an integer `k` representing the maximum number of transactions allowed. A single transaction consists of one purchase and one subsequent sale. You may not engage in multiple transactions simultaneously (i.e., you must sell the stock before you buy again). Return the maximum profit you can achieve with at most `k` transactions.