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

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode mergeTwoLists(ListNode list1, ListNode list2) {

        if(list1!=null && list2!=null){
        if(list1.val<list2.val){
            list1.next=mergeTwoLists(list1.next,list2);
            return list1;
            }
            else{
                list2.next=mergeTwoLists(list1,list2.next);
                return list2;
        }
        }
        if(list1==null)
            return list2;
        return list1;
    }
}

Учитывая n пар круглых скобок, напишите функцию, которая генерирует все комбинации правильных круглых скобок.

 public List<String> generateParenthesis(int n) {
        Set<String> ans = new HashSet<>();
        ans = createParenthesis(n, ans);
        System.out.println("Ans: " + ans);
        return new ArrayList<>(ans);
    }

    private static Set<String> createParenthesis(int n, Set<String> currentList) {
        java.util.Set<String> temp = new HashSet<>();
        if (n <= 0) return new HashSet<>();
        if (n == 1) {
            temp.add("()");
            return temp;
        }
        currentList = createParenthesis(n - 1, currentList);
        System.out.println("At n-1 " + String.valueOf(n-1) + ": " + currentList);
        for (String parenthesis : currentList) {
            for (int i = 0; i <= parenthesis.length(); i++) {
                String newStr;
                if (i == 0) {
                    System.out.println("At 0 for " + parenthesis);
                    newStr = "()" + parenthesis;
                    System.out.println(newStr);
                } else if (i == parenthesis.length()) {
                    System.out.println("At last for " + parenthesis);
                    newStr = parenthesis + "()";
                    System.out.println(newStr);
                } else {
                    System.out.println("At " + i + " for " + parenthesis);
                    newStr = parenthesis.substring(0, i) + "()" + parenthesis.substring(i);
                    System.out.println(newStr);
                }
                temp.add(newStr);
            }
        }
        currentList = temp;

        return currentList;
    }

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

class Solution {
    public ListNode mergeKLists(ListNode[] lists) {
        if(lists.length==0) return null;
        Queue<ListNode> minHeap = new PriorityQueue<>((head1,head2)->head1.val-head2.val);
        for(ListNode listNode: lists){
            if(listNode!=null) minHeap.offer(listNode);
        }
        ListNode head=null,cur=null;
        while(!minHeap.isEmpty()){
            ListNode curNode = minHeap.poll();
            if(curNode.next!=null) minHeap.offer(curNode.next);
            if(head==null){
                head = new ListNode(curNode.val);
                cur = head;
            }
            else{
                cur.next = new ListNode(curNode.val);
                cur = cur.next;
            }
        }
        return head;
    }
}

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

class Solution {
    public ListNode swapPairs(ListNode head) {
        if(head == null || head.next==null) return head;
        ListNode second = head.next;
        ListNode pr = swapPairs(second.next);
        second.next = head;
        head.next = pr;
        return second;
    }
}

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

 public ListNode reverseKGroup(ListNode head, int k) {
        
        ListNode dummy = new ListNode(-1);
        dummy.next = head;
        ListNode pointer = dummy;
        
        while (pointer != null) {
            ListNode node = pointer;
            for (int i = 0; i < k && node != null; i++) node = node.next;
            if (node == null) break;
            
            // reverse the k nodes
            ListNode prev = null, curr = pointer.next;
            for (int i = 0; i < k; i++) {
                ListNode next = curr.next;
                curr.next = prev;
                prev = curr;
                curr = next;
            }
            
            ListNode tail = pointer.next;
            tail.next = curr;
            pointer.next = prev;
            pointer = tail;
        }
        
        return dummy.next;
    }

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

class Solution {
    public int removeDuplicates(int[] nums) {
        int n = nums.length;
        if(n<=1){return n;}
        
        int left = 0; //everything to the left of left(inclusive) is good
        int right = 1;//the current element we are processing
        
        while(right<=n-1){
            if(nums[right] == nums[left]){
                right++;
            }
            else{
                nums[left+1] = nums[right];
                left++;
                right++;
            }
        }
        
        return left+1;
    }
}

Учитывая целочисленный массив nums и целочисленное значение, удалите все вхождения val в nums на месте. Порядок элементов может быть изменен. Затем верните количество элементов в виде чисел, которые не равны val.
Учитывайте количество элементов в nums, которые не равны val be k. Чтобы вас приняли, вам необходимо сделать следующее:
Измените массив nums так, чтобы первые k элементов nums содержали элементы, не равные val. Остальные элементы nums не важны, как и размер nums.
Вернуть К.

class Solution {
    public int removeElement(int[] nums, int val) {
        
        int left_most_index = 0;
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] != val) {
                nums[left_most_index++] = nums[i];
            }
        }
        return left_most_index;        
    }
}

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

public class Solution {
    
    private int[] failureFunction(char[] str) {
        int[] f = new int[str.length+1];
        for (int i = 2; i < f.length; i++) {
            int j = f[i-1];
            while (j > 0 && str[j] != str[i-1]) j = f[j];
            if (j > 0 || str[j] == str[i-1]) f[i] = j+1;
        }
        return f;
    }

    public int strStr(String haystack, String needle) {
        if (needle.length() == 0) return 0;
        if (needle.length() <= haystack.length()) {
            int[] f = failureFunction(needle.toCharArray());
            int i = 0, j = 0;
            while (i < haystack.length()) {
                if (haystack.charAt(i) == needle.charAt(j)) {
                    i++; j++;
                    if (j == needle.length()) return i-j;
                } else if (j > 0) j = f[j];
                else i++;
            }
        }
        return -1;
    }
}

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

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

public int divide(int dividend, int divisor) {
  long result = divideLong(dividend, divisor);
  return result > Integer.MAX_VALUE ? Integer.MAX_VALUE : (int)result;
}

// It's easy to handle edge cases when
// operate with long numbers rather than int
public long divideLong(long dividend, long divisor) {
  
  // Remember the sign
  boolean negative = dividend < 0 != divisor < 0;
  
  // Make dividend and divisor unsign
  if (dividend < 0) dividend = -dividend;
  if (divisor < 0) divisor = -divisor;
  
  // Return if nothing to divide
  if (dividend < divisor) return 0;
  
  // Sum divisor 2, 4, 8, 16, 32 .... times
    long sum = divisor;
    long divide = 1;
    while ((sum+sum) <= dividend) {
      sum += sum;
      divide += divide;
    }
    
    // Make a recursive call for (devided-sum) and add it to the result
    return negative ? -(divide + divideLong((dividend-sum), divisor)) :
      (divide + divideLong((dividend-sum), divisor));
}

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

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

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

class Solution {
    public List<Integer> findSubstring(String s, String[] words) {
        List<Integer> answer = new ArrayList<>();
        HashMap<String,Integer> mapOfWords = new HashMap<>();
        for(String word: words) mapOfWords.put(word,mapOfWords.getOrDefault(word,0)+1);
        int k = words[0].length();
        int n = words.length*k;
        int sLen = s.length();
        if(sLen<n) return answer;
        int[] arr = new int[26];
        for(String word: words){
            for(int i=0;i<k;i++){
                arr[word.charAt(i)-'a']++;
            }
        }
        int start=0,end=n-1;
        for(int i=0;i<=end;i++) arr[s.charAt(i)-'a']--;
        while(end<s.length()-1){
            if(allZeros(arr)&&validWords(s.substring(start,end+1),new HashMap<>(mapOfWords),k)) answer.add(start);
            arr[s.charAt(start)-'a']++;
            start++;end++;
            arr[s.charAt(end)-'a']--;
        }
        if(allZeros(arr)&&validWords(s.substring(start,end+1),new HashMap<>(mapOfWords),k)) answer.add(start);
        return answer;
    }
    public boolean allZeros(int[] arr){
        return Arrays.stream(arr).allMatch(i->i==0);
    }
    public boolean validWords(String s, HashMap<String,Integer> mapOfWords, int k){
        for(int i=0;i*k<s.length();i++){
            String currentString = s.substring(i*k,(i+1)*k);
            if(mapOfWords.containsKey(currentString)){
                mapOfWords.put(currentString,mapOfWords.get(currentString)-1);
                if(mapOfWords.get(currentString)<0) return false;
            }
            else return false;
        }
        return true;
    }
}