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

class Solution { 
public: 
    vector<vector<int>> fourSum(vector<int>& nums, int target) { 
        int n=nums.size(); 
        vector<vector<int>>ans; 
        sort(nums.begin(),nums.end()); 
 
        for(int a=0;a<n;a++) 
        { 
            for(int b=a+1;b<n;b++) 
            { 
                int c=b+1; 
                int d=n-1; 
                while(c<d) 
                { 
                    long long sum=nums[a]; 
                    sum+=nums[b]; 
                    sum+=nums[c]; 
                    sum+=nums[d]; 
                    if(sum<target) 
                    { 
                        c++; 
                    } 
                    else if(sum>target) 
                    { 
                        d--; 
                    } 
                    else 
                    { 
                        vector<int>v={nums[a],nums[b],nums[c],nums[d]}; 
                        //if new quads then push to main vector 
                        if(find(ans.begin(),ans.end(),v)==ans.end())  
                        { 
                            ans.push_back(v); 
                        } 
                        c++; 
                        d--; 
                    } 
                } 
            } 
        } 
        return ans; 
    } 
};

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

/** 
 * Definition for singly-linked list. 
 * struct ListNode { 
 *     int val; 
 *     ListNode *next; 
 *     ListNode() : val(0), next(nullptr) {} 
 *     ListNode(int x) : val(x), next(nullptr) {} 
 *     ListNode(int x, ListNode *next) : val(x), next(next) {} 
 * }; 
 */ 
class Solution { 
public: 
    ListNode* removeNthFromEnd(ListNode* head, int n) { 
        ListNode *slow, *fast; 
        slow=head; 
        fast=head; 
        ListNode *prev=new ListNode(0,head); 
        ListNode *answer=prev; 
        while(n>1){ 
            fast=fast->next; 
            n--; 
        } 
        while(fast->next){ 
            fast=fast->next; 
            slow=slow->next; 
            prev=prev->next; 
        } 
        prev->next=slow->next; 
        return answer->next; 
    } 
};

Учитывая строку s, содержащую только символы '(', ')', '{', '}', '[' и ']', определите, является ли входная строка допустимой. Входная строка действительна, если: Открытые скобки должны закрываться скобками того же типа.
Открытые скобки должны закрываться в правильном порядке.Каждой закрывающей скобке соответствует открытая скобка того же типа.

class Solution { 
public: 
    bool isValid(string s) { 
        stack<char> st; // create an empty stack to store opening brackets 
        for (char c : s) { // loop through each character in the string 
            if (c == '('  c == '{'  c == '[') { // if the character is an opening bracket 
                st.push(c); // push it onto the stack 
            } else { // if the character is a closing bracket 
                if (st.empty()  // if the stack is empty or  
                    (c == ')' && st.top() != '(')  // the closing bracket doesn't match the corresponding opening bracket at the top of the stack 
                    (c == '}' && st.top() != '{') || 
                    (c == ']' && st.top() != '[')) { 
                    return false; // the string is not valid, so return false 
                } 
                st.pop(); // otherwise, pop the opening bracket from the stack 
            } 
        } 
        return st.empty(); // if the stack is empty, all opening brackets have been matched with their corresponding closing brackets, 
                           // so the string is valid, otherwise, there are unmatched opening brackets, so return false 
    } 
};

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

class Solution { 
public: 
    ListNode* mergeTwoLists(ListNode* list1, ListNode* list2) { 
        ListNode* dummy = new ListNode(0); 
        ListNode* cur = dummy; 
 
        while (list1 && list2) { 
            if (list1->val > list2->val) { 
                cur->next = list2; 
                list2 = list2->next; 
            } else { 
                cur->next = list1; 
                list1 = list1->next; 
            } 
            cur = cur->next; 
        } 
 
        cur->next = list1 ? list1 : list2; 
 
        return dummy->next;         
    } 
};

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

class Solution { 
public: 
    vector<string> res; 
 
    void dfs(string cur, int open, int close, int n) 
    { 
        if (cur.length() == 2 * n) 
        { 
            if (open == close) res.push_back(cur); 
            return; 
        } 
 
        if (open < n) dfs(cur + "(", open + 1, close, n); 
        if (open > close) dfs(cur + ")", open, close + 1, n); 
    } 
 
    vector<string> generateParenthesis(int n) { 
        dfs("", 0, 0, n); 
        return res; 
    } 
};

. vector<string> res;: Это вектор, который будет хранить все сгенерированные правильные последовательности скобок.

2. void dfs(string cur, int open, int close, int n):
- Эта функция использует глубинный поиск (DFS) для генерации правильных последовательностей скобок.
- Параметры:
- cur: текущая строка с частично сформированной последовательностью скобок.
- open: количество открывающих скобок в cur.
- close: количество закрывающих скобок в cur.
- n: заданное число, которое определяет, сколько пар скобок нужно сгенерировать.
- Если длина cur равна 2 * n (то есть количество открывающих скобок равно количеству закрывающих скобок), проверяем, что open равно close, и если так, добавляем cur в res.
- Если количество открывающих скобок меньше n, рекурсивно вызываем dfs() с добавлением открывающей скобки.
- Если количество открывающих скобок больше количества закрывающих скобок, рекурсивно вызываем dfs() с добавлением закрывающей скобки.

3. vector<string> generateParenthesis(int n):
- Это основная функция, которая вызывает dfs() с начальными параметрами.
- Она инициализирует пустую строку cur, а также open и close равные 0.
- Затем вызывает dfs() и возвращает res, содержащий все сгенерированные правильные последовательности скобок.

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

/** 
 * Definition for singly-linked list. 
 * struct ListNode { 
 *     int val; 
 *     ListNode *next; 
 *     ListNode() : val(0), next(nullptr) {} 
 *     ListNode(int x) : val(x), next(nullptr) {} 
 *     ListNode(int x, ListNode *next) : val(x), next(next) {} 
 * }; 
 */ 
 class compare{ 
    public: 
    bool operator()(ListNode* a, ListNode* b){ 
    return a->val > b->val; 
 
    } 
 }; 
class Solution { 
public: 
    ListNode* mergeKLists(vector<ListNode*>& lists) { 
        if(lists.empty()){ 
            return NULL; 
        } 
 
         
     priority_queue<ListNode*, vector<ListNode*>, compare> minheap; 
    for(int i=0;i<lists.size();i++){ 
        if(lists[i]!=NULL) 
    minheap.push(lists[i]); 
    }   
     
    ListNode* head=NULL; 
    ListNode* temp1; 
    while(!minheap.empty()){ 
    ListNode* temp= minheap.top(); 
    
    if(head==NULL){ 
    head=temp; 
     temp1=temp;} 
     else{ 
     temp1->next=temp; 
     temp1=temp;} 
 
    minheap.pop(); 
    if(temp->next!=NULL){ 
        minheap.push(temp->next); 
    } 
 
 
  
    } 
    if(temp1!=NULL) 
    temp1->next=NULL; 
    return head;  
         
    } 
};
 

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

class Solution { 
public: 
    ListNode* swapPairs(ListNode* head) { 
        ListNode *temp = (ListNode*)malloc(sizeof(ListNode)); //dummy node 
        temp->next = head; 
 
        ListNode *ptr = temp,*swap1,*swap2; // pointers  
 
        while(ptr->next && ptr->next->next){  //atleast 2 nodes shold be present for swapping 
 
            swap1 = ptr->next; // node1  
            swap2 = ptr->next->next; // node2 
 
            swap1->next = swap2->next; // swapping nodes link just like variables 
            swap2->next = swap1; 
 
            ptr->next = swap2; // updation of ptr's next   
            ptr = swap1;  // updation of ptr 
        } 
        return temp->next; 
    } 
}; 
 

1. Инициализация Dummy-узла:
* Создаем фиктивный узел temp типа ListNode* и устанавливаем его next на head (начальный узел списка). Это позволяет нам обрабатывать случай, когда список пуст или содержит только один узел.
2. Инициализация Указателей:
* Устанавливаем указатель ptr на temp (фиктивный узел).* Устанавливаем указатели swap1 и swap2 на nullptr.
3. Итерация по списку:
* Заходим в цикл while, если ptr->next и ptr->next->next не равны nullptr. Это означает, что в списке есть по крайней мере два узла для обмена.
4. Обмен узлов:
* Устанавливаем swap1 на ptr->next (первый узел для обмена).
* Устанавливаем swap2 на ptr->next->next (второй узел для обмена).* Меняем ссылки next для swap1 и swap2. Это по существу обменивает два узла.
* Устанавливаем ptr->next на swap2. Это обновляет ссылку next для ptr.* Обновляем ptr на swap1. Это перемещает указатель вперед к следующему узлу первого обмена.
5. Возврат результата:
* После завершения обработки всех пар узлов возвращаем temp->next (фиктивный узел temp был добавлен в начале, поэтому его нужно пропустить)

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

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

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

/** 
 * Definition for singly-linked list. 
 * struct ListNode { 
 *     int val; 
 *     ListNode *next; 
 *     ListNode() : val(0), next(nullptr) {} 
 *     ListNode(int x) : val(x), next(nullptr) {} 
 *     ListNode(int x, ListNode *next) : val(x), next(next) {} 
 * }; 
 */ 
class Solution { 
public: 
    int count(ListNode* head){ 
        int n=0; 
        while(head){ 
            head=head->next; 
            n++; 
        } 
        return n; 
    } 
    ListNode* reverseKGroup(ListNode* head, int k) { 
 
          // bc 
          int num=count(head);                                       
          if(num<k){ 
              return head; 
          } 
          int x=k; 
          ListNode *next, *prev=NULL; 
          ListNode *curr=head; 
          while(x--){ 
              next=curr->next; 
              curr->next=prev; 
              prev=curr; 
              curr=next; 
          } 
          // 1->2->3->4.... 
          head->next= reverseKGroup(next,k); 
          return prev; 
    } 
};

1. Начинаем с определения структуры listnode, представляющей узел списка с одним целочисленным значением val и указателем на следующий узел next.

2.В классе solution определяем метод count для подсчета количества узлов в списке.

3.В методе reversekgroup определяем базовый случай: если количество узлов в списке меньше k, то просто возвращаем исходный список.

4.Затем определяем переменные num (количество узлов в списке), x (количество элементов, которые нужно развернуть в группе), указатели next (следующий узел), prev (предыдущий узел) и curr (текущий узел).

5.Затем в цикле с помощью x устанавливаем указатели и переворачиваем каждую группу по k элементов, меняя указатели на следующий и предыдущий узлы.

6.После переворота текущей группы устанавливаем указатель на следующий узел (next) равным результату рекурсивного вызова функции для следующей группы с параметром k.

7.Наконец, возвращаем указатель на первый узел в перевернутой группе (prev).

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

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

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

class Solution { 
public: 
    int removeDuplicates(vector<int>& nums) { 
        if (nums.empty()) { 
            return 0; 
        } 
 
        int k = 1; // Initialize the count of unique elements to 1 
        for (int i = 1; i < nums.size(); i++) { 
            if (nums[i] != nums[i - 1]) { 
                nums[k] = nums[i]; // Overwrite the next unique element 
                k++; 
            } 
        } 
         
        return k; 
    } 
};

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

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

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

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int cnt=0, sz=nums.size();
        for(int i=0; i<nums.size(); i++){
            if(nums[i]==val){
                cnt++;
                nums.erase(nums.begin()+i);
                i--;
            }
        }
        return sz-cnt;
    }
};

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

class Solution {
public:
  int strStr(string haystack, string needle) {
    if(haystack.size()<needle.size()){return -1;}
    if(haystack.size()==needle.size()){if(haystack==needle){return 0;}else{return -1;}}
    for(int i=0; i<haystack.size()-needle.size()+1; i++){
      string s=haystack.substr(i, needle.size());
      //cout<<s<<endl;
      if(s==needle){
        return 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.

class Solution {
public:
  int divide(int dividend, int divisor) {
    if((long long int)dividend/divisor>pow(2,31)-1){return pow(2,31)-1;}
    if((long long int)dividend/divisor<(-1)*(pow(2,31))){return -1*pow(2,31);}
    return dividend/divisor;
  }
};

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

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

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

    vector<int> findSubstring(string str, vector<string>& words) {
        int len = words[0].length();
        
        unordered_map<string, int> contain;
        for(string s: words) contain[s]++;
        
        vector<int> res;
        for(int j = 0; j < len; j++) {
            unordered_map<string, int> found;
            int st = j;
            for(int i = 0 + j; i < str.size() - len + 1; i += len) {
                string curr = str.substr(i, len);
                if(contain.find(curr) != contain.end()) {
                    found[curr]++;
                    while(found[curr] > contain[curr]) {
                        found[str.substr(st, len)]--;
                        st += len;
                    }
                    int size = (i - st + len) / len;
                    if(size == words.size()) {
                        cout << j << " " << st << " " << i << endl;
                        res.push_back(st);
                    }
                } else {
                    found.clear();
                    st = i + len;
                }
            }
        }
        
        return res;
    }

Перестановка массива целых чисел — это расположение его членов в последовательность или линейный порядок.

Например, для arr = [1,2,3] следующие перестановки arr: [1,2,3], [1,3,2], [2, 1, 3], [2, 3, 1], [3,1,2], [3,2,1].
Следующая перестановка массива целых чисел — это следующая лексикографически большая перестановка его целого числа. Более формально, если все перестановки массива отсортированы в одном контейнере в соответствии с их лексикографическим порядком, то следующей перестановкой этого массива будет перестановка, следующая за ней в отсортированном контейнере. Если такое расположение невозможно, массив необходимо переупорядочить в наименьшем возможном порядке (т. е. отсортировать по возрастанию).

Например, следующая перестановка arr = [1,2,3] — это [1,3,2].
Аналогично, следующая перестановка arr = [2,3,1] — это [3,1,2].
А следующая перестановка arr = [3,2,1] — это [1,2,3], потому что [3,2,1] не имеет более крупной лексикографической перестановки.
Учитывая массив целых чисел nums, найдите следующую перестановку чисел.

Замена должна быть на месте и использовать только постоянную дополнительную память.

class Solution {
public:
    void nextPermutation(vector<int>& nums) {
        
        int n = nums.size()-1;
        int index = n-1;
        while(index >= 0 && nums[index] >= nums[index+1])
            index--;
        
        if(index >= 0) {
            int nextGreaterElement = nums[index+1];
            int nextGreaterIndex = index+1;

            for(int i=index+1; i <= n; i++)
            {
                if(nums[i] > nums[index] && nums[i] < nextGreaterElement)
                {
                    nextGreaterElement = nums[i];
                    nextGreaterIndex = i;
                }
            }
            swap(nums[index], nums[nextGreaterIndex]);
        }
        sort(nums.begin()+index+1, nums.end());
    }
};

Учитывая строку, содержащую только символы «(» и «)», верните длину самых длинных допустимых (правильно сформированных) круглых скобок.
подстрока

class Solution {
public:
    int longestValidParentheses(string s) {
        stack<int> stack;
        int m = 0;
        stack.push(-1);
        for (int i = 0; i < s.length(); i++) {
            if (s[i] == '(') {
                stack.push(i);
            } else {
                stack.pop();
                if (stack.empty()) {
                    stack.push(i);
                } else {
                    m = max(m, (i - stack.top()));
                }
            }
        }
        return m;
    }
};

Существует целочисленный массив nums, отсортированный по возрастанию (с разными значениями).

Перед передачей в вашу функцию nums, возможно, поворачивается с неизвестным индексом поворота k (1 <= k < nums.length), так что результирующий массив имеет вид [nums[k], nums[k+1],... , nums[n-1], nums[0], nums[1], ..., nums[k-1]] (с индексом 0). Например, [0,1,2,4,5,6,7] можно повернуть с опорным индексом 3 и превратить в [4,5,6,7,0,1,2].

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

Вы должны написать алгоритм со сложностью выполнения O(log n).

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int left = 0, right = nums.size() - 1;
        while (left <= right) {
            if (nums[left] == target) {
                return left;
            } else if (nums[right] == target) {
                return right;
            }
            int m = (left + right) / 2;
            if (nums[m] == target) {
                return m;
            }
            if (nums[left] > nums[right]) {
                left++, right--;
            } else {
                if (nums[m] > target) {
                    right = m - 1, left++;
                } else {
                    left = m + 1, right--;
                }
            }
        }
        return -1;
    }
};

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

Если цель не найдена в массиве, верните [-1, -1].

Вы должны написать алгоритм со сложностью выполнения O(log n).

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
       vector<int> ans{-1,-1};
        auto l = lower_bound(nums.begin(),nums.end(),target);
        auto r = upper_bound(nums.begin(),nums.end(),target);
        if(l!=nums.end()&&*l==target){
        ans[0] = l-nums.begin();
        ans[1] = r-nums.begin()-1;
        }
        return ans;
    }
};