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

public class Solution {
    public int ThreeSumClosest(int[] nums, int target) {
        if(nums.Length < 3)
            return 0;

        Array.Sort(nums);
        int start = 0;
        int left = 1;
        int right = nums.Length - 1;
        int direction = nums[start] + nums[left] + nums[right] > 0 ? 1 : 0;
        int minDistance = int.MaxValue;
        int sum = int.MinValue;

        while (start < nums.Length - 2)
        {
            while (left < right)
            {
                int currSum = nums[start] + nums[left] + nums[right];
                if ( currSum == target )
                    return target;
                
                if (currSum < target)
                    left++;
                else 
                    right--;

                if (Math.Abs(currSum - target) < minDistance)
                {
                    sum = currSum;
                    minDistance = Math.Abs(currSum - target);
                }
            }
            start ++;
            left = start + 1;
            right = nums.Length - 1;
        }
        return sum;
    }
}

Учитывая строку, содержащую цифры от 2 до 9 включительно, верните все возможные комбинации букв, которые может представлять число. Верните ответ в любом порядке. Соответствие цифр буквам (как на кнопках телефона) приведено ниже. Обратите внимание, что 1 не соответствует никаким буквам.

public class Solution 
{
    Dictionary<char, char[]> keypad = new Dictionary<char, char[]> {{'2', new char[]{'a', 'b', 'c'}}, 
    {'3', new char[]{'d', 'e', 'f'}}, {'4', new char[] {'g', 'h', 'i'}}, 
    {'5', new char[] {'j', 'k', 'l'}}, {'6', new char[] {'m', 'n', 'o'}}, 
    {'7', new char[] {'p', 'q', 'r', 's'}}, {'8', new char[] {'t', 'u', 'v'}}, 
    {'9', new char[] {'w', 'x', 'y', 'z'}}};

    public void AddCombination(string curr, string digits, int index, IList<string> list)
    {
        if(index >= digits.Length) list.Add(curr);
        else
        {
            char[] map = keypad[digits[index]];

            for(int i = 0; i < map.Length; i++)
            {
                string newCurr = curr + map[i];

                AddCombination(newCurr, digits, index + 1, list);
            }
        }
    }

    public IList<string> LetterCombinations(string digits) 
    {
        IList<string> combinations = new List<string>();

        if(digits.Length > 0) AddCombination("", digits, 0, combinations);

        return combinations;
    }
}

Учитывая массив nums из n целых чисел, верните массив всех уникальных четверок [nums[a], nums[b], nums[c], nums[d]] таких, что:
0 <= a, b, c, d < n
a, b, c и d различны.
nums[a] + nums[b] + nums[c] + nums[d] == цель
Вы можете вернуть ответ в любом порядке.

public class Solution {
    public IList<IList<int>> FourSum(int[] nums, int target) {
        var rs = new List<IList<int>>();
        Array.Sort(nums);
        Helper(rs, nums, target, 4, 0, new List<int>());
        return rs;
    }

    private void Helper(List<IList<int>> rs, int[] nums, long target, int k, int index, List<int> subList) {
        if (k == 2) {
            int l = index;
            int r = nums.Length - 1;
            while (l < r) {
                long sum = nums[l] + nums[r];
                if (sum == target) {
                    subList.Add(nums[l]);
                    subList.Add(nums[r]);
                    rs.Add(new List<int>(subList));
                    subList.RemoveAt(subList.Count - 1);
                    subList.RemoveAt(subList.Count - 1);
                    while (l < r && nums[l] == nums[l + 1]) {
                        l++;
                    }
                    while (l < r && nums[r - 1] == nums[r]) {
                        r--;
                    }
                    l++;
                    r--;
                } else if (sum < target) {
                    l++;
                } else {
                    r--;
                }
            }
        } else {
            for (int i = index; i < nums.Length - k + 1; i++) {
                if (i != index && nums[i] == nums[i - 1]) {
                    continue;
                }
                subList.Add(nums[i]);
                Helper(rs, nums, target - nums[i], k - 1, i + 1, subList);
                subList.RemoveAt(subList.Count - 1);
            }
        }
    }
}

Учитывая заголовок связанного списка, удалите n-й узел из конца списка и верните его заголовок.

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     public int val;
 *     public ListNode next;
 *     public ListNode(int val=0, ListNode next=null) {
 *         this.val = val;
 *         this.next = next;
 *     }
 * }
 */
public class Solution {
    public ListNode RemoveNthFromEnd(ListNode head, int n) {
        int length = 0;
        ListNode curr = head;
        
        // Find the length of the linked list
        while (curr != null) {
            length++;
            curr = curr.next;
        }
        
        int traverseTill = length - n - 1;
        curr = head;
        
        // Traverse to the node before the one to be removed
        for (int i = 0; i < traverseTill; i++) {
            curr = curr.next;
        }
        
        // Remove the nth node from the end
        if (traverseTill == -1) {
            return head.next;
        } else {
            curr.next = curr.next.next;
            return head;
        }
    }
}

Вам даны заголовки двух отсортированных связанных списков list1 и list2. Объедините два списка в один отсортированный список. Список должен быть составлен путем сращивания узлов первых двух списков. Возвращает заголовок объединенного связанного списка.

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     public int val;
 *     public ListNode next;
 *     public ListNode(int val=0, ListNode next=null) {
 *         this.val = val;
 *         this.next = next;
 *     }
 * }
 */
public class Solution {
    public ListNode MergeTwoLists(ListNode list1, ListNode list2) {
        ListNode dummyHead = new ListNode(-1); 
        // Create a dummy node as the starting point
        ListNode current = dummyHead; 
        // Pointer to keep track of the current node

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

        // Attach the remaining nodes if any
        if (list1 != null) {
            current.next = list1;
        } else {
            current.next = list2;
        }

        return dummyHead.next; 
        // Return the merged list starting from the node after the dummy head

    }
}