Input: n = 3, k = 7
Output: [181,292,707,818,929]
Explanation: Note that 070 is not a valid number, because it has leading zeroes.

public class Solution {
    public int[] NumsSameConsecDiff(int N, int K) {
        if (N == 1) return Enumerable.Range(0, 10).ToArray();
        
        var queue = new List<int>(Enumerable.Range(1, 9));
        for (int level = 1; level < N; ++level) {
            var nextQueue = new List<int>();
            foreach (int num in queue) {
                int tailDigit = num % 10;
                var nextDigits = new int[] { tailDigit + K, tailDigit - K };
                
                foreach (int nextDigit in nextDigits) {
                    if (nextDigit >= 0 && nextDigit < 10) {
                        nextQueue.Add(num * 10 + nextDigit);
                    }
                }
            }
            queue = nextQueue;
        }
        
        return queue.ToArray();
    }
}

Input: blocked = [[0,1],[1,0]], source = [0,0], target = [0,2]
Output: false

public class Solution {
    public bool IsBoomerang(int[][] points) {
        int x1 = points[0][0], y1 = points[0][1];
        int x2 = points[1][0], y2 = points[1][1];
        int x3 = points[2][0], y3 = points[2][1];
        return (x1 != x2 || y1 != y2) && 
               (x1 != x3 || y1 != y3) && 
               (x2 != x3 || y2 != y3) && 
               (x1 * (y2 - y3) + x2 * (y3 - y1) + x3 * (y1 - y2)) != 0;
    }
}

Input: n = 1
Output: true
Explanation: Alice can remove 1 stone winning the game because Bob doesn't have any moves.

public class Solution {
    public bool WinnerSquareGame(int n) {
        Dictionary<int, bool> cache = new Dictionary<int, bool>();
        cache[0] = false;
        return Dfs(cache, n);
    }

    public bool Dfs(Dictionary<int, bool> cache, int remain) {
        if (cache.ContainsKey(remain)) {
            return cache[remain];
        }
        int sqrtRoot = (int) Math.Sqrt(remain);
        for (int i = 1; i <= sqrtRoot; ++i) {
            if (!Dfs(cache, remain - i * i)) {
                cache[remain] = true;
                return true;
            }
        }
        cache[remain] = false;
        return false;
    }
}

Input: n = 3, goal = 3, k = 1
Output: 6

public class Solution {
    public int NumMusicPlaylists(int n, int goal, int k) {
        const int MOD = 1_000_000_007;
        long[,] dp = new long[goal + 1, n + 1];
        dp[0, 0] = 1;

        for (int i = 1; i <= goal; i++) {
            for (int j = 1; j <= n; j++) {
                dp[i, j] = dp[i - 1, j - 1] * (n - j + 1) % MOD;
                if (j > k) {
                    dp[i, j] = (dp[i, j] + dp[i - 1, j] * (j - k) % MOD) % MOD;
                }
            }
        }

        return (int)dp[goal, n];
    }
}

Input: s = "lee(t(c)o)de)"
Output: "lee(t(c)o)de"

public class Solution {
    public string MinRemoveToMakeValid(string s) {
        var stack = new Stack<int>();
        var sb = new StringBuilder(s);
        for (int i = 0; i < sb.Length; i++) {
            if (sb[i] == '(') {
                stack.Push(i);
            } else if (sb[i] == ')') {
                if (stack.Count > 0) {
                    stack.Pop();
                } else {
                    sb[i] = '*';
                }
            }
        }
        while (stack.Count > 0) {
            sb[stack.Pop()] = '*';
        }
        return sb.ToString().Replace("*", "");
    }
}

Input: arr = [2,1,4,7,3,2,5]
Output: 5
Explanation: The largest mountain is [1,4,7,3,2] which has length 5.

public class Solution {
    public int LongestMountain(int[] arr) {
        int n = arr.Length;
        int ans = 0;
        int baseIndex = 0;

        while (baseIndex < n) {
            int end = baseIndex;
            if (end + 1 < n && arr[end] < arr[end + 1]) {
                while (end + 1 < n && arr[end] < arr[end + 1]) {
                    end++;
                }
                if (end + 1 < n && arr[end] > arr[end + 1]) {
                    while (end + 1 < n && arr[end] > arr[end + 1]) {
                        end++;
                    }
                    ans = Math.Max(ans, end - baseIndex + 1);
                }
            }
            baseIndex = Math.Max(end, baseIndex + 1);
        }

        return ans;
    }
}

Input: nodes = 7, parent = [-1,0,0,1,2,2,2], value = [1,-2,4,0,-2,-1,-1]
Output: 2

using System;
using System.Collections.Generic;

public class Solution {
    public int DeleteTreeNodes(int nodes, int[] parent, int[] value) {
        var tree = new Dictionary<int, List<int>>();
        for (int i = 0; i < nodes; i++) {
            if (!tree.ContainsKey(parent[i])) tree[parent[i]] = new List<int>();
            tree[parent[i]].Add(i);
        }

        (int, int) Dfs(int node) {
            int totalSum = value[node];
            int totalCount = 1;
            if (tree.ContainsKey(node)) {
                foreach (int child in tree[node]) {
                    var (childSum, childCount) = Dfs(child);
                    totalSum += childSum;
                    totalCount += childCount;
                }
            }
            return totalSum == 0 ? (0, 0) : (totalSum, totalCount);
        }

        return Dfs(0).Item2;
    }
}

Input: n = 3, goal = 3, k = 1
Output: 6

public class Solution {
    public int MinAddToMakeValid(string s) {
        int openNeeded = 0;
        int closeNeeded = 0;
        
        foreach (char c in s) {
            if (c == '(') {
                openNeeded++;
            } else if (c == ')') {
                if (openNeeded > 0) {
                    openNeeded--;
                } else {
                    closeNeeded++;
                }
            }
        }
        
        return openNeeded + closeNeeded;
    }
}

Input: moves = "UD"
Output: true

public class Solution {
    public bool JudgeCircle(string moves) {
        int x = 0, y = 0;
        foreach (char move in moves) {
            switch (move) {
                case 'R': x++; break;
                case 'L': x--; break;
                case 'U': y++; break;
                case 'D': y--; break;
            }
        }
        return x == 0 && y == 0;
    }
}

Input: board = [[-1,-1,-1,-1,-1,-1],[-1,-1,-1,-1,-1,-1],[-1,-1,-1,-1,-1,-1],[-1,35,-1,-1,13,-1],[-1,-1,-1,-1,-1,-1],[-1,15,-1,-1,-1,-1]]
Output: 4

using System;
using System.Collections.Generic;

public class Solution {
    public int SnakesAndLadders(int[][] board) {
        int n = board.Length;

        int[] GetPos(int x) {
            int quot = (x - 1) / n;
            int rem = (x - 1) % n;
            int row = n - 1 - quot;
            int col = (row % 2 != n % 2) ? rem : n - 1 - rem;
            return new int[] { row, col };
        }

        var visited = new HashSet<int>();
        var queue = new Queue<int[]>();
        queue.Enqueue(new int[] { 1, 0 });

        while (queue.Count > 0) {
            var curr = queue.Dequeue();
            int pos = curr[0];
            int steps = curr[1];
            for (int i = 1; i <= 6; i++) {
                int nextPos = pos + i;
                if (nextPos > n * n) continue;
                var rc = GetPos(nextPos);
                int r = rc[0], c = rc[1];
                if (board[r][c] != -1) {
                    nextPos = board[r][c];
                }
                if (nextPos == n * n) {
                    return steps + 1;
                }
                if (!visited.Contains(nextPos)) {
                    visited.Add(nextPos);
                    queue.Enqueue(new int[] { nextPos, steps + 1 });
                }
            }
        }
        return -1;
    }
}

Input: arr = [1,15,7,9,2,5,10], k = 3
Output: 84

public class Solution {
    public int MaxSumAfterPartitioning(int[] arr, int k) {
        int n = arr.Length;
        int[] dp = new int[n];
        
        for (int i = 0; i < n; i++) {
            int maxVal = 0;
            for (int j = 1; j <= k; j++) {
                if (i - j + 1 >= 0) {
                    maxVal = Math.Max(maxVal, arr[i - j + 1]);
                    if (i - j >= 0) {
                        dp[i] = Math.Max(dp[i], dp[i - j] + maxVal * j);
                    } else {
                        dp[i] = Math.Max(dp[i], maxVal * j);
                    }
                }
            }
        }
        
        return dp[n - 1];
    }
}

Input: words = ["dog","cat","dad","good"], letters = ["a","a","c","d","d","d","g","o","o"], score = [1,0,9,5,0,0,3,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0]
Output: 23

public class Solution {
    public int MaxScoreWords(string[] words, char[] letters, int[] score) {
        Dictionary<char, int> letterCount = new Dictionary<char, int>();
        foreach (char ch in letters) {
            if (!letterCount.ContainsKey(ch)) {
                letterCount[ch] = 0;
            }
            letterCount[ch]++;
        }

        int WordScore(string word) {
            int total = 0;
            foreach (char ch in word) {
                total += score[ch - 'a'];
            }
            return total;
        }

        bool CanFormWord(string word, Dictionary<char, int> letterCount) {
            Dictionary<char, int> count = new Dictionary<char, int>();
            foreach (char ch in word) {
                if (!count.ContainsKey(ch)) {
                    count[ch] = 0;
                }
                count[ch]++;
                if (count[ch] > letterCount.GetValueOrDefault(ch, 0)) {
                    return false;
                }
            }
            return true;
        }

        int maxScore = 0;
        int n = words.Length;
        for (int i = 1; i < (1 << n); i++) {
            int currScore = 0;
            Dictionary<char, int> usedLetters = new Dictionary<char, int>();
            bool valid = true;
            for (int j = 0; j < n; j++) {
                if ((i & (1 << j)) != 0) {
                    string word = words[j];
                    if (CanFormWord(word, letterCount)) {
                        currScore += WordScore(word);
                        foreach (char ch in word) {
                            if (!usedLetters.ContainsKey(ch)) {
                                usedLetters[ch] = 0;
                            }
                            usedLetters[ch]++;
                        }
                    } else {
                        valid = false;
                        break;
                    }
                }
            }
            if (valid) {
                maxScore = Math.Max(maxScore, currScore);
            }
        }

        return maxScore;
    }
}

Input: n = 2, start = 3
Output: [3,2,0,1]

using System;
using System.Collections.Generic;
using System.Linq;

public class Solution {
    public IList<int> CircularPermutation(int n, int start) {
        var gray = GrayCode(n);
        int startIndex = gray.IndexOf(start);
        var result = new List<int>();
        result.AddRange(gray.Skip(startIndex));
        result.AddRange(gray.Take(startIndex));
        return result;
    }

    private List<int> GrayCode(int n) {
        var result = new List<int>();
        int numElements = 1 << n;
        for (int i = 0; i < numElements; i++) {
            result.Add(i ^ (i >> 1));
        }
        return result;
    }
}

Input: arr1 = [2,3,1,3,2,4,6,7,9,2,19], arr2 = [2,1,4,3,9,6]
Output: [2,2,2,1,4,3,3,9,6,7,19]

public class Solution {
    public int[] RelativeSortArray(int[] arr1, int[] arr2) {
        var countMap = new Dictionary<int, int>();
        var remaining = new List<int>();
        var result = new List<int>();

        foreach (var value in arr2) {
            countMap[value] = 0;
        }

        foreach (var value in arr1) {
            if (countMap.ContainsKey(value)) {
                countMap[value]++;
            } else {
                remaining.Add(value);
            }
        }

        remaining.Sort();

        foreach (var value in arr2) {
            for (int i = 0; i < countMap[value]; i++) {
                result.Add(value);
            }
        }

        result.AddRange(remaining);
        return result.ToArray();
    }
}

Input: nums = [4,5,6,7,0,1,2], target = 0  
Output: 4  

public class Solution {
    public int Search(int[] nums, int target) {
        int left = 0, right = nums.Length - 1;

        while (left <= right) {
            int 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;
    }
}

Input: grid = [[1,0,0,0,0,0,1],[2,0,0,0,0,3,0],[2,0,9,0,0,0,0],[0,3,0,5,4,0,0],[1,0,2,3,0,0,6]]
Output: 28
Explanation: Path of robot #1 and #2 are described in color green and blue respectively.
Cherries taken by Robot #1, (1 + 9 + 5 + 2) = 17.
Cherries taken by Robot #2, (1 + 3 + 4 + 3) = 11.
Total of cherries: 17 + 11 = 28.

public class Solution {
    public int CherryPickup(int[][] grid) {
        int m = grid.Length;
        int n = grid[0].Length;
        int[,,] dp = new int[m, n, n];
        
        for (int row = m - 1; row >= 0; row--) {
            for (int col1 = 0; col1 < n; col1++) {
                for (int col2 = 0; col2 < n; col2++) {
                    int result = grid[row][col1];
                    if (col1 != col2) {
                        result += grid[row][col2];
                    }
                    if (row != m - 1) {
                        int maxCherries = 0;
                        for (int newCol1 = col1 - 1; newCol1 <= col1 + 1; newCol1++) {
                            for (int newCol2 = col2 - 1; newCol2 <= col2 + 1; newCol2++) {
                                if (newCol1 >= 0 && newCol1 < n && newCol2 >= 0 && newCol2 < n) {
                                    maxCherries = Math.Max(maxCherries, dp[row + 1, newCol1, newCol2]);
                                }
                            }
                        }
                        result += maxCherries;
                    }
                    dp[row, col1, col2] = result;
                }
            }
        }
        return dp[0, 0, n - 1];
    }
}

Input: words = ["bella","label","roller"]
Output: ["e","l","l"]

public class Solution {
    public IList<string> CommonChars(string[] words) {
        int[] minFreq = new int[26];
        Array.Fill(minFreq, int.MaxValue);
        
        foreach (string word in words) {
            int[] freq = new int[26];
            foreach (char c in word) {
                freq[c - 'a']++;
            }
            for (int i = 0; i < 26; i++) {
                minFreq[i] = Math.Min(minFreq[i], freq[i]);
            }
        }
        
        IList<string> result = new List<string>();
        for (int i = 0; i < 26; i++) {
            for (int j = 0; j < minFreq[i]; j++) {
                result.Add(((char)('a' + i)).ToString());
            }
        }
        return result;
    }
}

Input
["TimeMap", "set", "get", "get", "set", "get", "get"]
[[], ["foo", "bar", 1], ["foo", 1], ["foo", 3], ["foo", "bar2", 4], ["foo", 4], ["foo", 5]]
Output
[null, null, "bar", "bar", null, "bar2", "bar2"]

public class Solution {
    public IList<int> PancakeSort(int[] A) {
        var ans = new List<int>();
        for (int valueToSort = A.Length; valueToSort > 0; valueToSort--) {
            int index = Find(A, valueToSort);
            if (index == valueToSort - 1) {
                continue;
            }
            if (index != 0) {
                ans.Add(index + 1);
                Flip(A, index + 1);
            }
            ans.Add(valueToSort);
            Flip(A, valueToSort);
        }
        return ans;
    }

    protected void Flip(int[] sublist, int k) {
        int i = 0;
        while (i < k / 2) {
            int temp = sublist[i];
            sublist[i] = sublist[k - i - 1];
            sublist[k - i - 1] = temp;
            i += 1;
        }
    }

    protected int Find(int[] a, int target) {
        for (int i = 0; i < a.Length; i++) {
            if (a[i] == target) {
                return i;
            }
        }
        return -1;
    }
}