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

class Solution { 
public: 
    int threeSumClosest(vector<int>& nums, int target) { 
        sort(nums.begin(),nums.end()); 
        int front; 
        int sum=nums[0]+nums[1]+nums[2],sum1=0; 
        for(int i=0;i<nums.size();i++){ 
            front=i+1; 
            int back=nums.size()-1; 
            while(front<back){ 
            sum1=nums[front]+nums[back]+nums[i]; 
            if(abs(sum1-target)<=abs(sum-target)){ 
                sum=sum1; 
            } 
            if(sum1>target)  
                back--; 
            else if(sum1<target)  
               front++; 
            else return sum1; 
            } 
        } 
        return sum; 
    } 
};

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

class Solution { 
public: 
    void find(string digits,vector<string>v,vector<string>&res,string s,int k){ 
        if(k>=digits.size()){ 
            res.push_back(s); 
            return; 
        } 
        int a = digits[k] - '0'; 
        for(int i=0;i<v[a].size();i++){ 
            s+=v[a][i]; 
            find(digits,v,res,s,k+1); 
            s.pop_back(); 
        } 
    } 
    vector<string> letterCombinations(string digits) { 
        vector<string>res; 
        if(digits.size()==0) return res; 
        vector<string>v={"","","abc","def","ghi","jkl","mno","pqrs","tuv","wxyz"}; 
        int k=0; 
        string s=""; 
        find(digits,v,res,s,k); 
        return res; 
    } 
};

Учитывая массив 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 
    } 
};