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

/**
 * @param {string} s
 * @return {boolean}
 */
var isValid = function (s) {
    let stk = [];
    for (const c of s) {
        if (c == '('  c == '{'  c == '[') {
            stk.push(c);
        } else if (stk.length == 0  !match(stk[stk.length - 1], c)) {
            return false;
        } else {
            stk.pop();
        }
    }
    return stk.length == 0;
};

function match(l, r) {
    return (l == '(' && r == ')')  (l == '[' && r == ']') || (l == '{' && r == '}');
}

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

/
 * Definition for singly-linked list.
 * function ListNode(val, next) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.next = (next===undefined ? null : next)
 * }
 */
/
 * @param {ListNode} list1
 * @param {ListNode} list2
 * @return {ListNode}
 */
var mergeTwoLists = function (list1, list2) {
    if (!list1  !list2) {
        return list1  list2;
    }
    if (list1.val <= list2.val) {
        list1.next = mergeTwoLists(list1.next, list2);
        return list1;
    } else {
        list2.next = mergeTwoLists(list1, list2.next);
        return list2;
    }
};

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

/**
 * @param {number} n
 * @return {string[]}
 */
var generateParenthesis = function (n) {
    function dfs(l, r, t) {
        if (l > n  r > n  l < r) {
            return;
        }
        if (l == n && r == n) {
            ans.push(t);
            return;
        }
        dfs(l + 1, r, t + '(');
        dfs(l, r + 1, t + ')');
    }
    let ans = [];
    dfs(0, 0, '');
    return ans;
};

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

/
 * Definition for singly-linked list.
 * function ListNode(val, next) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.next = (next===undefined ? null : next)
 * }
 */
/
 * @param {ListNode[]} lists
 * @return {ListNode}
 */
var mergeKLists = function (lists) {
    const pq = new MinPriorityQueue({ priority: node => node.val });
    for (const head of lists) {
        if (head) {
            pq.enqueue(head);
        }
    }
    const dummy = new ListNode();
    let cur = dummy;
    while (!pq.isEmpty()) {
        const node = pq.dequeue().element;
        cur.next = node;
        cur = cur.next;
        if (node.next) {
            pq.enqueue(node.next);
        }
    }
    return dummy.next;
};

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

/
 * Definition for singly-linked list.
 * function ListNode(val, next) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.next = (next===undefined ? null : next)
 * }
 */
/
 * @param {ListNode} head
 * @return {ListNode}
 */
var swapPairs = function (head) {
    if (!head || !head.next) {
        return head;
    }
    const t = swapPairs(head.next.next);
    const p = head.next;
    p.next = head;
    head.next = t;
    return p;
};

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

/**
 * @param {number[]} nums
 * @return {number}
 */
var removeDuplicates = function (nums) {
    let k = 0;
    for (const x of nums) {
        if (k === 0 || x !== nums[k - 1]) {
            nums[k++] = x;
        }
    }
    return k;
};

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

/**
 * @param {number[]} nums
 * @param {number} val
 * @return {number}
 */
var removeElement = function (nums, val) {
    let k = 0;
    for (const x of nums) {
        if (x !== val) {
            nums[k++] = x;
        }
    }
    return k;
};

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

function strStr(haystack, needle) {  if (needle === "") {
    return 0;  }
  for (let i = 0; i < haystack.length; i++) {
    let haySlice = haystack.slice(i, i + needle.length);    if (haySlice === 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.

var divide = function(dividend, divisor) {    if(dividend===0) return 0;
    let signal = 1;    if(dividend<0){
        signal *= -1;    }
    if(divisor<0){        signal *= -1;
    }    dividend = Math.abs(dividend);
    divisor = Math.abs(divisor);    
    let result = help(dividend, divisor)*signal;    if(result>Math.pow(2,31)-1){
        result = Math.pow(2,31)-1;    }else if(result<-1*Math.pow(2,31)){
        result = Math.pow(2,31)*(-1);    }
    return result;    
        function help(dividend, divisor){            if(dividend < divisor) return 0;
            let res = 0;            let origDivisor = divisor;
            let prev = 0;            while(dividend>=divisor){
                if(res===0){                    res += 1;
                }else{                    res += res;
                }                prev = divisor;
                divisor += divisor;            }
            dividend -= prev;            res += help(dividend, origDivisor);
            return res;        }
};

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

var findSubstring = function(s, words) {
    let len = words[0].length;    let windowSize = words.length * len;
    if (s.length < windowSize) {        return [];
    }    let m = new Map(), res = [];
    // Fill Hash table with entry being (word, number of occurrences)    for (let i = 0; i < words.length; i++) {
        m.set(words[i], m.get(words[i]) + 1  1);    }
    let start = 0;    while (start + windowSize - 1 < s.length) {
        if (isConcat(s, new Map(m), len, start, start + windowSize-1)) {            res.push(start);
        }        start++;
    }    return res;
    // Let M be the length of s, N be the number of words    // T.C: O(M*N)
    // S.C: O(M*N), new map is used for every iteration};
const isConcat = (s, m, len, start, end) => {
    let chars = m.size;    for (let i = start; i <= end; i += len) {
        let substr = s.substring(i, i+len);        if (!m.has(substr)  m.get(substr) === 0) return false;
        m.set(substr, m.get(substr) - 1);        if (m.get(substr) === 0) {
            chars--;        }
    }    return chars === 0;
    // if we consider time complexity of substring() to be O(1),    // T.C: O(N)
}

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

var nextPermutation = function(nums) {
  const len = nums.length;
  let i = len - 2, j = len - 1, k = len - 1;
  while (i >= 0 && nums[i] >= nums[j]) {
    i--;
    j--;
  }
  if (i >= 0) {
    while (nums[i] >= nums[k]) {
      k--;
    }
    [nums[i], nums[k]] = [nums[k], nums[i]];
  }
  twoPointerReverse(j, len-1, nums);
  return nums;
  
  function twoPointerReverse(left, right, nums) {
    while (left < right) {
      let tmp = nums[left];
      nums[left] = nums[right];
      nums[right] = tmp;
      left++;
      right--;
    }
  }   
};

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

var longestValidParentheses = function(s) {
    const n = s.length;    const S = [-1];
    let x = 0;    for (let i = 0; i < n; ++i)
        if (s[i] === '(')             S.push(i); // open; mark start index
        else {            S.pop(); // close; remove a start index
            if (!S.length)                 S.push(i); // invalid; reset index to new start
            else                 x = Math.max(x, i - S[S.length - 1]); // valid; save the length
        }    return x;
};

Существует целочисленный массив 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).

/** * @param {number[]} nums
 * @param {number} target * @return {number}
 */var search = function(nums, target) {
    let res=nums.indexOf(target);
    if(res){        return res;
    }    else if(res==-1)
    {        return -1;
    }    else{
        return res;    }
    };

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

/** * @param {number[]} nums
 * @param {number} target * @return {number}
 */var searchInsert = function(nums, target) {
  if (nums.indexOf(target) === -1) {    for (let i = 0; i <= nums.length; ) {
      if (nums[i] < target) {        i++;
      } else {          return i
      }    }
  } else {    return nums.indexOf(target);
  }};

Определите, действительна ли доска для судоку 9 x 9. Только заполненные ячейки подлежат проверке согласно следующим правилам:
Каждая строка должна содержать цифры от 1 до 9 без повторений.Каждый столбец должен содержать цифры 1–9 без повторений.
Каждый из девяти подполей сетки размером 3х3 должен содержать цифры от 1 до 9 без повторений.Примечание:
Доска судоку (частично заполненная) может быть допустимой, но не обязательно решаемой.
Только заполненные ячейки должны быть проверены в соответствии с указанными правилами.

/**
 * @param {character[][]} board * @return {boolean}
 */var isValidSudoku = function(board) {
    let rowMap = new Map();    let colmMap = new Map();
    let grid33 = new Map();
    for (let i = 0; i < 9; i++) {        
        for (let j = 0; j < 9; j++){           let m =  board[3 * Math.floor(i / 3) + Math.floor(j / 3)][((i * 3) % 9) + (j % 3)]
           if(!rowMap.get(board[i][j])  board[i][j] == '.' ) {               rowMap.set(board[i][j], 1)
           }              else { return false}
             if (!colmMap.get(board[j][i])  board[j][i] == '.' ) {                   colmMap.set(board[j][i], 1)
            }              else { return false}
             if (!grid33.get(m) || m == '.'){                grid33.set(m, 1)
            }            else { return false}
                            
          
        }        rowMap.clear();
         grid33.clear();        colmMap.clear();
    }    return true
};

Последовательность count-and-say - это последовательность цифровых строк, определяемая рекурсивной формулой:

count-And-Say(1) = "1"
countAndSay(n) - это кодировка длины цикла countAndSay(n - 1).
Кодирование по длине строки (RLE) - это метод сжатия строк, который работает путем замены последовательных идентичных символов (повторяющихся 2 или более раз) путем объединения символа и числа, обозначающего количество символов (длину строки). Например, чтобы сжать строку "3322251", мы заменяем "33" на "23", заменяем "222" на "32", заменяем "5" на "15" и заменяем "1" на "11". Таким образом, сжатая строка становится "23321511".

Учитывая положительное целое число n, верните n-й элемент последовательности подсчета и произнесения.

class Solution {
  countAndSay(n) {
    if (n === 1) {
      return "1"; // Base case
    }

    let ans = "";
    let temp = "1";

    for (let i = 2; i <= n; i++) {
      let cnt = 0;
      let prev = temp[0];

      for (let j = 0; j < temp.length; j++) {
        const char = temp[j];

        if (prev === char) {
          cnt++; // brute force
        } else {
          ans += cnt.toString(); // adding count to the end
          ans += temp[j - 1];
          prev = char;
          cnt = 1;
        }
      }

      ans += cnt.toString();
      ans += temp[temp.length - 1];
      temp = ans; // assigning ans to temp and making ans = ""
      ans = ""; // so that we can iterate over temp again!
    }

    return temp;
  }
}

При наличии массива различных целых чисел-кандидатов и целевого целевого числа target возвращает список всех уникальных комбинаций кандидатов, в которых выбранные числа суммируются с target. Вы можете возвращать комбинации в любом порядке.
Одно и то же число может быть выбрано из кандидатов неограниченное количество раз. Две комбинации считаются уникальными, если частота, по крайней мере, одного из выбранных чисел различна.
Тестовые примеры генерируются таким образом, чтобы количество уникальных комбинаций, которые в сумме дают целевое значение, составляло менее 150 комбинаций для заданных входных данных.

/**
 * @param {number[]} candidates
 * @param {number} target
 * @return {number[][]}
 */
var combinationSum = function(candidates, target) {
    let sols = [];
    let sum_rec = (curr_trial, curr_sum, start_idx) => {
        for (let i = start_idx; i < candidates.length; i++) {
            const c = candidates[i];
            curr_sum += c;
            curr_trial.push(c);
            if (curr_sum < target) {
                sum_rec(curr_trial, curr_sum, i);
            } else if (curr_sum === target) {
                sols.push(JSON.parse(JSON.stringify(curr_trial)));
            }
            curr_sum -= c;
            curr_trial.pop();
        }
    }
    sum_rec([], 0, 0);
    return sols;
};

Учитывая набор номеров-кандидатов (candidates) и целевой номер (target), найдите все уникальные комбинации в кандидатах, где номера-кандидаты суммируются с целевыми.
Каждое число в кандидатах является комбинацией.
может использоваться только один раз в
Примечание: Набор решений не должен содержать повторяющихся комбинаций.

var combinationSum2 = function(candidates, target) {
    
    const res = [];
    const track = [];
    let trackSum = 0;
    
    const backtrack = (nums, start) => {
        if(trackSum === target){
            res.push(track.slice());
            return
        }
        if(trackSum > target){
            return
        }
        
        for(let i = start; i < nums.length; i++){
            if(i > start && nums[i] === nums[i-1]) continue;
            track.push(nums[i]);
            trackSum += nums[i];
            backtrack(nums, i+1);
            track.pop();
            trackSum -= nums[i];
        }
        
    }
    
    const sorted = candidates.sort((a, b)=>a-b);
    
    backtrack(sorted, 0)
    return res
    
};

Задан несортированный целочисленный массив nums. Возвращает наименьшее положительное целое число, которого нет в nums.
Необходимо реализовать алгоритм, который выполняется за 0(n) времени и использует 0(1) вспомогательного пространства.

/**
 * @param {number[]} nums
 * @return {number}
 */
var firstMissingPositive = function(nums) {
    const n = nums.length
    const n1 = n + 1
    for (let i = 0; i < n; i++) 
        if (nums[i] <= 0 || nums[i] > n)
            nums[i] = n1
    for (let num of nums) {
        i = Math.abs(num) - 1
        if (i < n && nums[i] > 0)
            nums[i] *= -1
    }
    for (let i = 0; i < n; i++) 
        if (nums[i] > 0)
            return i + 1
    return n1  
};