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

class Solution {
    fun isValid(s: String): Boolean {
        
        if (s.length == 1) {
        return false
    }

    val stack = Stack<Char>()

    s.forEach {
        when(it) {
            '(', '[', '{' -> {
                stack.push(it)
            }
            ')', ']', '}' -> {
                if(stack.isEmpty() || !isMatchingPair(stack.pop(), it)) {
                    return false
                }
            }
            else -> return false
        }
    }

    return stack.isEmpty()

    }

fun isMatchingPair(open: Char, close: Char): Boolean {
    return (open == '(' && close == ')')  (open == '[' && close == ']')  (open == '{' && close == '}')
    }
}

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

class Solution {
    fun permute(nums: IntArray): List<List<Int>> {
        val answer: MutableList<List<Int>> = mutableListOf()
        permutations(mutableListOf(), nums.toMutableList(), answer)
        return answer
    }
    
    fun permutations(current: MutableList<Int>, remaining: MutableList<Int>, result: MutableList<List<Int>>) {
        if(remaining.isEmpty()) result.add(current)
        remaining.forEach {
            current.add(it)
            permutations(current.toMutableList(), remaining.toMutableList().also { m -> m.remove(it) }, result)
            current.removeAt(current.size - 1)
        }
    }
}

Вам предоставляется массив целых чисел nums с индексом 0 и длиной n. Изначально вы располагаетесь в nums [0].
Каждый элемент nums [i] представляет максимальную длину прямого перехода от индекса i. Другими словами, если вы находитесь в nums [1], вы можете перейти к любому nums [i + j], где:
• <=j<= nums[i] и
• i+j <n
Возвращает минимальное количество переходов для достижения nums [n -
11. Тестовые примеры генерируются таким образом, чтобы вы могли достичь значений [n - 1].

class Solution {
    fun jump(nums: IntArray): Int {
        val m = nums.size
        if(m<2){
            return 0
        }
        val dp = IntArray(m){Int.MAX_VALUE}
        dp[0] = 0
        var t = 0
        for (i in 0 until m){
            for(j in 1 until nums[i]+1){
                if(i+j<m){
                    dp[i+j] = minOf(dp[i+j], dp[i]+1)                    
                }
            }
        }
        return dp[m-1]
    }
}

Учитывая входную строку (строки) и шаблон (p), реализуйте сопоставление шаблонов с подстановочными знаками с поддержкой '?' и '*', где:
"?'
Соответствует любому отдельному символу.
'*'
Соответствует любой последовательности символов (включая пустую последовательность).
Соответствие должно охватывать всю входную строку (не частичное).

class Solution {
    fun isMatch(s: String, p: String): Boolean {
        val ss = s.split("").filter{it -> it != ""}
        val ps = p.split("").filter{it -> it != ""}
        val m = ps.size
        val n = ss.size
        var i1 = 0
        var i2 = 0
        var start = -1
        while (i2 < n){
            if (i1<m && (ps[i1]==ss[i2] || ps[i1]=="?")){
                i1 = i1+1
                i2 = i2+1
            }
            else if(i1<m && ps[i1]=="*"){
                start = i1
                i1 = i1+1
            }
            else if(start != -1){
                i2 = i2-(i1-start-1)+1
                i1 = start+1
            }
            else{
                return false
            }
        }
        while (i1<m && ps[i1]=="*"){
            i1++
        }
        if (i1==m){
            return true
        }
        return false
    }
}

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

class Solution {
    fun mergeTwoLists(list1: ListNode?, list2: ListNode?): ListNode? {
        if (list1 == null && list2 == null) {
            return null
        }
        if (list1 == null) {
            return list2
        }
        if (list2 == null) {
            return list1
        }
        if (list1.val < list2.val) {
            list1.next = mergeTwoLists(list1.next, list2)
            return list1
        }
        list2.next = mergeTwoLists(list2.next, list1)
        return list2
    }
}

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

class Solution {
fun generateParenthesis(n: Int): List<String> {
    val list = ArrayList<String>()
    x(charArrayOf(),n,n,list)


return list
}

fun x(str:CharArray, left:Int, right:Int,list:ArrayList<String>){
    if (left==0 && right==0) {
        list.add(String(str))
    }
    else {
        if (left <= right && left!=0) x(str.plus('('), left - 1, right,list)
        if (right!=0) x(str.plus(')'), left, right - 1,list)
    }
}
}

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

Объедините все связанные списки в один отсортированный связанный список и верните его.

class Solution {
  fun mergeKLists(lists: Array<ListNode?>): ListNode? {
    val pq = PriorityQueue<ListNode>() { a, b -> a.`val` - b.`val` }
    lists.filter { it != null }.forEach { pq.add(it) }
    val res = ListNode(-1)
    var tail = res
    while (pq.isNotEmpty()) {
      val head = pq.poll()
      tail.next = head
      tail = tail.next!!
      if (head.next != null)
        pq.add(head.next)
    }
    return res.next
  }
}

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

class Solution {
  fun swapPairs(head: ListNode?): ListNode? {
    val dummy = ListNode(-1)
    var head = head
    var cur: ListNode? = dummy
    while (head != null) {
      val A = head
      head = head.next
      val B = head
      head = head?.next
      if (B == null) {
        cur!!.next = A
      } else {
        B.next = A
        A.next = null
        cur!!.next = B
        cur = A
      }
    }
    return dummy.next
  }
}

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

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

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

import java.util.Stack
class Solution {
    fun reverseKGroup(head: ListNode?, k: Int): ListNode? {
        if (head == null) return null

        var num = k
        var first = head
        var last = head


        while (--num > 0 && last != null) {
            last = last.next
        }

        if (last != null) {
            var nextHead = last.next
            val stack = Stack<ListNode>()
            while (first != last) {
                stack.push(first)
                first = first!!.next
            }

            while (!stack.empty()) {
                last!!.next = stack.pop()
                last = last!!.next
            }

            last!!.next = reverseKGroup(nextHead, k)
        }

        return first
    }
}

fun removeDuplicates(nums: IntArray): Int {

    if (nums.isEmpty()) return 0

    var lastIdx = 1
    var curVal = nums[0]

    nums.forEachIndexed { i, _ ->
        if (nums[i] > curVal) {
            curVal = nums[i]
            nums[lastIdx] = nums[i]
            lastIdx++
        }
    }

    return lastIdx
}`

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

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

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

  fun removeElement(nums: IntArray, `val`: Int): Int {
        val c = nums.filter { it != `val` }
        for ((a, b) in c.withIndex()) { nums[a] = b }
        return c.size
    }

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

class Solution {
    fun strStr(haystack: String, needle: String): Int {
        return haystack.indexOf(needle)
    }
}

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

Целочисленное деление должно сокращаться до нуля, что означает потерю дробной части. Например, 8,345 будет сокращено до 8, а -2,7335 будет сокращено до -2.

Возвращает частное после деления делимого на делитель.

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

class Solution {
  fun divide(dividend: Int, divisor: Int): Int {

    var isNegtive = (dividend > 0 && divisor < 0 || dividend < 0 && divisor > 0)
    var dividendLong = Math.abs(dividend.toLong())
    var divisorLong = Math.abs(divisor.toLong())

    var i = 0
    while ((divisorLong shl  i) <= dividendLong) {
      i ++
    }

    var res = 0L
    (i - 1 downTo 0)
        .forEach {
          val cur = (divisorLong shl  it)
          if (dividendLong >= cur) {
            res += (1L shl  it)
            dividendLong -= cur
          }
        }

    return if (isNegtive) {
      -res.toInt()
    } else {
      Math.min(Int.MAX_VALUE.toLong(), res).toInt()
    }
  }
}

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

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

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

class Solution {
    fun findSubstring(s: String, words: Array<String>): List<Int> {
        val ml = mutableListOf<Int>()
        if (s == ""){
            return ml
        }
        if (words.size == 0){
            return ml
        }
        val w = words.sorted().groupingBy{it}.eachCount()
        val ws = words[0].length * words.size
        for (i in 0 until s.length - ws + 1){
            if (s
                    .substring(i until i+ws)
                    .chunked(words[0].length)
                    .sorted()
                    .groupingBy{it}
                    .eachCount()
                    .equals(w)){
                ml.add(i)
            }
        }
        return ml
    }
}