Input: root = [1,2,3,2,null,2,4], target = 2
Output: [1,null,3,null,4]
Explanation: Leaf nodes in green with value (target = 2) are removed (Picture in left). 
After removing, new nodes become leaf nodes with value (target = 2) (Picture in center).

public class Solution {
    public TreeNode RemoveLeafNodes(TreeNode root, int target) {
        if (root == null) {
            return null;
        }

        root.left = RemoveLeafNodes(root.left, target);
        root.right = RemoveLeafNodes(root.right, target);

        if (root.left == null && root.right == null && root.val == target) {
            return null;
        }
        return root;
    }
}

Input: nums = [3,6,9,1]
Output: 3
Explanation: The sorted form of the array is [1,3,6,9], either (3,6) or (6,9) has the maximum difference 3.

public class Solution {
    public int MaximumGap(int[] nums) {
        if (nums == null ||
            nums.Length < 2) 
            return 0;

        Array.Sort(nums);

        int maxGap = 0;

        for (int i = 0; i < nums.Length - 1; i++)
            maxGap = Math.Max(nums[i + 1] - nums[i], maxGap);

        return maxGap;
    }
}

Input
["RangeModule", "addRange", "removeRange", "queryRange", "queryRange", "queryRange"]
[[], [10, 20], [14, 16], [10, 14], [13, 15], [16, 17]]
Output
[null, null, null, true, false, true]

public class RangeModule {

    private List<(int, int)> ranges;

    public RangeModule() {
        ranges = new List<(int, int)>();
    }

    public void AddRange(int left, int right) {
        var newRanges = new List<(int, int)>();
        int i = 0;
        while (i < ranges.Count && ranges[i].Item2 < left) {
            newRanges.Add(ranges[i]);
            i++;
        }
        while (i < ranges.Count && ranges[i].Item1 <= right) {
            left = Math.Min(left, ranges[i].Item1);
            right = Math.Max(right, ranges[i].Item2);
            i++;
        }
        newRanges.Add((left, right));
        while (i < ranges.Count) {
            newRanges.Add(ranges[i]);
            i++;
        }
        ranges = newRanges;
    }

    public bool QueryRange(int left, int right) {
        foreach (var range in ranges) {
            if (range.Item1 <= left && right <= range.Item2) {
                return true;
            }
        }
        return false;
    }

    public void RemoveRange(int left, int right) {
        var newRanges = new List<(int, int)>();
        foreach (var range in ranges) {
            if (range.Item1 < left) {
                newRanges.Add((range.Item1, Math.Min(range.Item2, left)));
            }
            if (right < range.Item2) {
                newRanges.Add((Math.Max(range.Item1, right), range.Item2)));
            }
        }
        ranges = newRanges;
    }
}

Input
["MyCircularDeque", "insertLast", "insertLast", "insertFront", "insertFront", "getRear", "isFull", "deleteLast", "insertFront", "getFront"]
[[3], [1], [2], [3], [4], [], [], [], [4], []]
Output
[null, true, true, true, false, 2, true, true, true, 4]

public class MyCircularDeque {
    private int[] deque;
    private int front;
    private int rear;
    private int size;
    private int capacity;

    public MyCircularDeque(int k) {
        capacity = k;
        deque = new int[k];
        front = 0;
        rear = 0;
        size = 0;
    }

    public bool InsertFront(int value) {
        if (IsFull()) return false;
        front = (front - 1 + capacity) % capacity;
        deque[front] = value;
        size++;
        return true;
    }

    public bool InsertLast(int value) {
        if (IsFull()) return false;
        deque[rear] = value;
        rear = (rear + 1) % capacity;
        size++;
        return true;
    }

    public bool DeleteFront() {
        if (IsEmpty()) return false;
        front = (front + 1) % capacity;
        size--;
        return true;
    }

    public bool DeleteLast() {
        if (IsEmpty()) return false;
        rear = (rear - 1 + capacity) % capacity;
        size--;
        return true;
    }

    public int GetFront() {
        if (IsEmpty()) return -1;
        return deque[front];
    }

    public int GetRear() {
        if (IsEmpty()) return -1;
        return deque[(rear - 1 + capacity) % capacity];
    }

    public bool IsEmpty() {
        return size == 0;
    }

    public bool IsFull() {
        return size == capacity;
    }
}

Input: nums = [1,17,8]
Output: 2

public class Solution {
    public int NumSquarefulPerms(int[] nums) {
        Array.Sort(nums);
        var used = new bool[nums.Length];
        var result = new HashSet<string>();
        var path = new List<int>();
        Backtrack(nums, used, path, result);
        return result.Count;
    }
    
    private void Backtrack(int[] nums, bool[] used, List<int> path, HashSet<string> result) {
        if (path.Count == nums.Length) {
            if (IsSquareful(path)) {
                result.Add(string.Join(",", path));
            }
            return;
        }
        
        for (int i = 0; i < nums.Length; i++) {
            if (used[i] || (i > 0 && nums[i] == nums[i - 1] && !used[i - 1])) continue;
            path.Add(nums[i]);
            used[i] = true;
            Backtrack(nums, used, path, result);
            path.RemoveAt(path.Count - 1);
            used[i] = false;
        }
    }
    
    private bool IsSquareful(List<int> perm) {
        for (int i = 0; i < perm.Count - 1; i++) {
            int sum = perm[i] + perm[i + 1];
            int root = (int)Math.Sqrt(sum);
            if (root * root != sum) return false;
        }
        return true;
    }
}

Input: s = "Hello World"  
Output: 5  
Explanation: Последнее слово — "World", его длина 5.  

public class Solution {
    public int LengthOfLastWord(string s) {
        int length = 0, i = s.Length - 1;

        while (i >= 0 && s[i] == ' ') i--; // Пропуск пробелов
        while (i >= 0 && s[i] != ' ') {   // Подсчет длины слова
            length++;
            i--;
        }

        return length;
    }
}

Input: num = 38
Output: 2
Explanation: The process is
38 --> 3 + 8 --> 11
11 --> 1 + 1 --> 2 
Since 2 has only one digit, return it.

public class Solution {
    public int AddDigits(int num) {
        int digital_root = 0;
        while (num > 0) {
            digital_root += num % 10;
            num /= 10;
            if (num == 0 && digital_root > 9) {
                num = digital_root;
                digital_root = 0;
            }
        }
        return digital_root;
    }
}

Input: n = 2
Output: ["11","69","88","96"]

using System;
using System.Collections.Generic;
using System.Text;

public class Solution {
    private List<List<char>> reversiblePairs = new List<List<char>> {
        new List<char>{'0', '0'}, new List<char>{'1', '1'}, 
        new List<char>{'6', '9'}, new List<char>{'8', '8'}, new List<char>{'9', '6'}
    };
    
    public List<string> GenerateStroboNumbers(int n, int finalLength) {
        if (n == 0) {
            return new List<string> { "" };
        }
        
        if (n == 1) {
            return new List<string> { "0", "1", "8" };
        }
        
        List<string> prevStroboNums = GenerateStroboNumbers(n - 2, finalLength);
        List<string> currStroboNums = new List<string>();
        
        foreach (string prevStroboNum in prevStroboNums) {
            foreach (List<char> pair in reversiblePairs) {
                if (pair[0] != '0' || n != finalLength) {
                    currStroboNums.Add(pair[0] + prevStroboNum + pair[1]);
                }
            }
        }
        
        return currStroboNums;
    }
    
    public List<string> FindStrobogrammatic(int n) {
        return GenerateStroboNumbers(n, n);
    }
}

Input: words1 = ["amazon","apple","facebook","google","leetcode"], words2 = ["e","o"]
Output: ["facebook","google","leetcode"]

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

public class Solution {
    public IList<string> WordSubsets(string[] words1, string[] words2) {
        int[] maxCount = new int[26];
        foreach (string word in words2) {
            int[] count = GetCount(word);
            for (int i = 0; i < 26; i++) {
                maxCount[i] = Math.Max(maxCount[i], count[i]);
            }
        }

        List<string> result = new List<string>();
        foreach (string word in words1) {
            int[] count = GetCount(word);
            if (IsUniversal(count, maxCount)) {
                result.Add(word);
            }
        }

        return result;
    }

    private int[] GetCount(string word) {
        int[] count = new int[26];
        foreach (char c in word) {
            count[c - 'a']++;
        }
        return count;
    }

    private bool IsUniversal(int[] count, int[] maxCount) {
        for (int i = 0; i < 26; i++) {
            if (count[i] < maxCount[i]) {
                return false;
            }
        }
        return true;
    }
}

Input: nums = [1000,100,10,2]
Output: "1000/(100/10/2)"
Explanation: 1000/(100/10/2) = 1000/((100/10)/2) = 200
However, the bold parenthesis in "1000/((100/10)/2)" are redundant since they do not influence the operation priority.
So you should return "1000/(100/10/2)".
Other cases:
1000/(100/10)/2 = 50
1000/(100/(10/2)) = 50
1000/100/10/2 = 0.5
1000/100/(10/2) = 2

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

public class Solution {
    private List<int> AddStrings(List<int> num1, List<int> num2) {
        var ans = new List<int>();
        int carry = 0;
        int n1 = num1.Count;
        int n2 = num2.Count;

        for (int i = 0; i < Math.Max(n1, n2) + 1; ++i) {
            int digit1 = i < n1 ? num1[i] : 0;
            int digit2 = i < n2 ? num2[i] : 0;
            int sum = digit1 + digit2 + carry;
            carry = sum / 10;
            ans.Add(sum % 10);
        }
        return ans;
    }

    private List<int> MultiplyOneDigit(string firstNumber, char secondNumberDigit, int numZeros) {
        var currentResult = new List<int>(new int[numZeros]);
        int carry = 0;

        foreach (char digit in firstNumber) {
            int multiplication = (secondNumberDigit - '0') * (digit - '0') + carry;
            carry = multiplication / 10;
            currentResult.Add(multiplication % 10);
        }
        if (carry != 0) {
            currentResult.Add(carry);
        }
        return currentResult;
    }

    public string Multiply(string firstNumber, string secondNumber) {
        if (firstNumber == "0" || secondNumber == "0") {
            return "0";
        }

        firstNumber = new string(firstNumber.Reverse().ToArray());
        secondNumber = new string(secondNumber.Reverse().ToArray());

        var ans = new List<int>(new int[firstNumber.Length + secondNumber.Length]);

        for (int i = 0; i < secondNumber.Length; ++i) {
            ans = AddStrings(MultiplyOneDigit(firstNumber, secondNumber[i], i), ans);
        }

        while (ans.Last() == 0) {
            ans.RemoveAt(ans.Count - 1);
        }

        var answer = new System.Text.StringBuilder();
        for (int i = ans.Count - 1; i >= 0; --i) {
            answer.Append(ans[i]);
        }

        return answer.ToString();
    }
}

public class Foo {
  public void first() { print("first"); }
  public void second() { print("second"); }
  public void third() { print("third"); }
}

Input: nums = [1,2,3]
Output: "firstsecondthird"
Explanation: There are three threads being fired asynchronously. The input [1,2,3] means thread A calls first(), thread B calls second(), and thread C calls third(). "firstsecondthird" is the correct output.

using System;
using System.Threading;

public class Foo {
    private SemaphoreSlim firstJobDone = new SemaphoreSlim(0, 1);
    private SemaphoreSlim secondJobDone = new SemaphoreSlim(0, 1);

    public void First(Action printFirst) {
        printFirst();
        firstJobDone.Release();
    }

    public void Second(Action printSecond) {
        firstJobDone.Wait();
        printSecond();
        secondJobDone.Release();
    }

    public void Third(Action printThird) {
        secondJobDone.Wait();
        printThird();
    }
}

Input: n = 4, leftChild = [1,-1,3,-1], rightChild = [2,-1,-1,-1]
Output: true

using System;
using System.Collections.Generic;

public class Solution {
    public bool ValidateBinaryTreeNodes(int n, int[] leftChild, int[] rightChild) {
        int[] parents = new int[n];
        
        for (int i = 0; i < n; i++) {
            if (leftChild[i] != -1) {
                if (++parents[leftChild[i]] > 1) {
                    return false;
                }
            }
            if (rightChild[i] != -1) {
                if (++parents[rightChild[i]] > 1) {
                    return false;
                }
            }
        }
        
        int root = -1;
        for (int i = 0; i < n; i++) {
            if (parents[i] == 0) {
                if (root == -1) {
                    root = i;
                } else {
                    return false;
                }
            }
        }
        
        if (root == -1) {
            return false;
        }
        
        HashSet<int> visited = new HashSet<int>();
        Queue<int> queue = new Queue<int>();
        queue.Enqueue(root);
        
        while (queue.Count > 0) {
            int node = queue.Dequeue();
            if (!visited.Add(node)) {
                return false;
            }
            if (leftChild[node] != -1) {
                queue.Enqueue(leftChild[node]);
            }
            if (rightChild[node] != -1) {
                queue.Enqueue(rightChild[node]);
            }
        }
        
        return visited.Count == n;
    }
}