Вам дан массив из k списков связанных списков, каждый связанный список отсортирован в порядке возрастания.

Объедините все связанные списки в один отсортированный связанный список и верните его.

public class Solution {
        public ListNode MergeKLists(ListNode[] lists)
        {            
            if (lists == null || lists.Length == 0)
                return null;
         
            return Merge(lists, 0, lists.Length - 1);
        }

        private ListNode Merge(ListNode[] lists, int i, int j)
        {
            if (j == i)
                return lists[i];
            else
            {
                int mid = i + (j - i) / 2;

                ListNode left = Merge(lists, i, mid),
                         right = Merge(lists, mid + 1, j);

                return Merge(left, right);
            }
        }

        private ListNode Merge(ListNode list1, ListNode list2)
        {
            ListNode dummy = new ListNode(0),
                     cur = dummy;

            while (list1 != null && list2 != null)
            {
                if (list1.val <= list2.val)
                {
                    cur.next = list1;
                    list1 = list1.next;
                }
                else
                {
                    cur.next = list2;
                    list2 = list2.next;
                }

                cur = cur.next;
            }

            if (list1 != null)
                cur.next = list1;

            if (list2 != null)
                cur.next = list2;

            return dummy.next;
        }
}

Данный код представляет собой класс `Solution`, в котором содержатся методы для объединения нескольких отсортированных списков в один общий отсортированный список. Давайте разберем пошагово, что происходит в каждом из методов:

1. Метод `MergeKLists` принимает массив списков `lists` и возвращает объединенный список. Если входной массив `lists` равен `null` или его длина равна 0, то метод вернет `null`. В противном случае метод вызывает вспомогательный метод `Merge`, передавая ему массив `lists`, начальный индекс 0 и конечный индекс `lists.Length - 1`.

2. В методе `Merge` осуществляется проверка условия, при котором начальный индекс `i` равен конечному индексу `j`. Если это условие выполняется, метод возвращает список из массива `lists` по индексу `i`. В противном случае происходит разбиение массива на две части посредством вычисления среднего индекса `mid`. Затем метод рекурсивно вызывает себя для левой половины массива и для правой половины массива, получая два подсписка `left` и `right`. Затем вызывается отдельный метод `Merge`, который объединяет два подсписка в один.

3. Метод `Merge` принимает два списка `list1` и `list2` и создает фиктивный узел `dummy`. При помощи указателя `cur` осуществляется сравнение элементов `val` двух списков и добавление их в новый список в отсортированном порядке. Таким образом, метод просматривает оба списка `list1` и `list2`, сравнивая и перенаправляя указатель на следующий минимальный элемент. П

Учитывая связанный список, поменяйте местами каждые два соседних узла и верните его голову. Вы должны решить проблему, не изменяя значения в узлах списка (т. е. изменять можно только сами узлы).

 public ListNode SwapPairs(ListNode head)
        {
            if (head == null)
                return head;

            ListNode s = head;
            ListNode h1 = head;
            ListNode h2 = head.next;

            while (h2 != null)
            {
                //SWAP
                var t = h1.val;
                h1.val = h2.val;
                h2.val = t;


                if (h2.next == null || h1.next.next == null)
                    break;

                // move by +2 
                h2 = h2.next.next;
                h1 = h1.next.next;
            }
            return s;
        }

Учитывая заголовок связанного списка, поменяйте местами узлы списка k за раз и верните измененный список.

k — целое положительное число, меньшее или равное длине связанного списка. Если количество узлов не кратно k, то пропущенные узлы в конечном итоге должны остаться такими, какие они есть.

Вы не можете изменять значения в узлах списка, можно изменять только сами узлы.

    public class Solution
    {
        //https://leetcode.com/problems/reverse-linked-list-ii/
        private void ReverseList(ListNode head, int m, int n, out ListNode groupHead)
        {
            var curr = head.next;
            var inputHead = head;
            int count = n - m;
            int idx = 0;

            while (idx < count)
            {
                inputHead.next = curr.next;
                curr.next = head;
                head = curr;
                curr = inputHead.next;
                idx++;
            }

            groupHead = head;
        }

        public ListNode ReverseKGroup(ListNode head, int k)
        {
            if (head == null)
            {
                return null;
            }

            int count = 0;
            ListNode curr = head;
            while (curr != null)
            {
                count++;
                curr = curr.next;
            }


            ListNode res = null;
            ListNode prev = null;
            curr = head;
            int idx = 0;

            while (true)
            {
                if (idx + k - 1 >= count)
                {
                    res = res ?? head;
                    break;
                }

                ReverseList(curr, idx, idx + k - 1, out ListNode groupHead);
                curr = groupHead;
                if (prev != null)
                {
                    prev.next = groupHead;
                }

                for (int i = 0; i < k; i++)
                {
                    prev = curr;
                    curr = curr.next;
                }

                res = res ?? groupHead;
                idx += k;
            }

            return res;
        }
    }

Учитывая целочисленный массив чисел, отсортированный в неубывающем порядке, удалите дубликаты на месте так, чтобы каждый уникальный элемент появлялся только один раз. Относительный порядок элементов должен оставаться неизменным. Затем верните количество уникальных элементов в числах.

Считайте, что количество уникальных элементов чисел равно k. Чтобы вас приняли, вам нужно сделать следующее:

Измените массив nums так, чтобы первые k элементов nums содержали уникальные элементы в том порядке, в котором они присутствовали в nums изначально. Остальные элементы nums не важны, как и размер nums.
Вернуть К.

public class Solution {
    public int RemoveDuplicates(int[] nums) {
        if (nums == null || nums.Length == 0)
            return 0;
        
        int i = 0;
        
        for (int j = 0; j < nums.Length; j++)
        {
            nums[i++] = nums[j];
            
            while (j < nums.Length - 1 && nums[j] == nums[j + 1])
                j++;
        }
        
        return i;
    }
}

Учитывая целочисленный массив nums и целочисленное значение, удалите все вхождения val в nums на месте. Порядок элементов может быть изменен. Затем верните количество элементов в виде чисел, которые не равны val.

Учитывайте количество элементов в nums, которые не равны val be k. Чтобы вас приняли, вам необходимо сделать следующее:

Измените массив nums так, чтобы первые k элементов nums содержали элементы, не равные val. Остальные элементы nums не важны, как и размер nums.
Вернуть К.

public class Solution {
    public int RemoveElement(int[] nums, int val) {
        if (nums == null || nums.Length == 0)
            return 0;
        
        int i = 0;
        
        for (int j = 0; j < nums.Length; j++)
        {
            while (j < nums.Length && nums[j] == val)
                j++;
            
            if (j < nums.Length)
                nums[i++] = nums[j];
        }
        
        return i;
    }
}

Учитывая целочисленный массив nums и целочисленное значение, удалите все вхождения val в nums на месте. Порядок элементов может быть изменен. Затем верните количество элементов в виде чисел, которые не равны val.

Учитывайте количество элементов в nums, которые не равны val be k. Чтобы вас приняли, вам необходимо сделать следующее:

Измените массив nums так, чтобы первые k элементов nums содержали элементы, не равные val. Остальные элементы nums не важны, как и размер nums.
Вернуть К.

public class Solution {
    public int RemoveElement(int[] nums, int val) {
        if (nums == null || nums.Length == 0)
            return 0;
        
        int i = 0;
        
        for (int j = 0; j < nums.Length; j++)
        {
            while (j < nums.Length && nums[j] == val)
                j++;
            
            if (j < nums.Length)
                nums[i++] = nums[j];
        }
        
        return i;
    }
}

Учитывая две строки, игла и стог сена, верните индекс первого вхождения иглы в стоге сена или -1, если игла не является частью стога сена.

public class Solution {
    public int StrStr(string haystack, string needle) {
        int i = 0,
            j = 0;
        int[] lps = BuildLPS(needle);
        
        while (i < haystack.Length && j < needle.Length)
            if (haystack[i] == needle[j])
            {
                i++;
                j++;
            }
            else
            {
                if (j > 0)
                    j = lps[j - 1];
                else
                    i++;
            }
        
        return j == needle.Length ? i - j : -1;
    }
    
    private int[] BuildLPS(string needle)
    {
        int[] lps = new int[needle.Length];
        int i = 0;
        
        for (int j = 1; j < needle.Length;)
            if (needle[i] == needle[j])
            {
                lps[j] = i + 1;
                
                i++;
                j++;
            }
            else
            {
                if (i > 0)
                    i = lps[i - 1];
                else
                    j++;
            }
        
        return lps;
    }
}

Учитывая два целых числа: делимое и делитель, разделите два целых числа, не используя операторы умножения, деления и модификатора.

Целочисленное деление должно сокращаться до нуля, что означает потерю дробной части. Например, 8,345 будет сокращено до 8, а -2,7335 будет сокращено до -2.

Возвращает частное после деления делимого на делитель.

Примечание. Предположим, мы имеем дело со средой, которая может хранить целые числа только в пределах 32-битного целого диапазона со знаком: [−2^31, 2^31 − 1]. В этой задаче, если частное строго больше 2^31 - 1, верните 2^31 - 1, а если частное строго меньше -2^31, верните -2^31.

public class Solution {
    public int Divide(int dividend, int divisor) {
        if(divisor == 0 || dividend == int.MinValue && divisor == -1) return int.MaxValue;
        
        int sign = (dividend < 0 ^ divisor < 0) ? -1 : 1, result = 0;
        
        long m = Math.Abs((long)dividend), n = Math.Abs((long)divisor);
        
        while(m >= n)
        {
            long subN = n;
            for(int subCount = 1; m >= subN; subCount <<= 1, subN <<= 1)
            {
                m -= subN;
                result += subCount;
            }
        }
        
        return sign == 1 ? result : (result - result - result);
    }
}

Вам дана строка s и массив строк-слов. Все строки слов имеют одинаковую длину.

Объединенная строка — это строка, которая в точности содержит все строки любой перестановки объединенных слов.

Например, если слова = ["ab", "cd", "ef"], то "abcdef", "abefcd", "cdabef", "cdefab", "efabcd" и "efcdab" являются объединенными строками. «acdbef» не является объединенной строкой, поскольку не является объединением какой-либо перестановки слов.
Возвращает массив начальных индексов всех объединенных подстрок в s. Вы можете вернуть ответ в любом порядке.

public class Solution {
    public IList<int> FindSubstring(string s, string[] words) {
        var size = words[0].Length;
        var window = size * words.Length;

        var wordMap = new Dictionary<string, int[]>();
        foreach (var word in words)
        {
            if (!wordMap.TryGetValue(word, out var map))
            {
                wordMap.Add(word, map = new int[2]);
            }

            map[0] += 1;
        }

        var checkMap = new List<(int index, string word)>();
        for (var i = 0; i <= s.Length - size; i++)
        {
            var word = s[i..(i + size)];
            if (wordMap.ContainsKey(word))
            {
                checkMap.Add((i, word));
            }
        }

        var result = new List<int>();
        var left = 0;
        while (left < checkMap.Count - words.Length)
        {
            var checkWindow = checkMap[left].index + window - size;
            var right = left;
            var prevIndex = -size;
            while (right < checkMap.Count && checkWindow >= checkMap[right].index)
            {
                if (checkMap[right].index >= prevIndex + size)
                {
                    wordMap[checkMap[right].word][1] += 1;
                    prevIndex = checkMap[right].index;
                }

                right++;
            }

            var found = true;
            foreach(var map in wordMap)
            {
                found &= map.Value[0] == map.Value[1];
                map.Value[1] = 0;
            }

            if (found)
            {
                result.Add(checkMap[left].index);
            }

            left++;
        }

        return result;
    }
}