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

func generateParenthesis(n int) []string {
    res := make([]string, 0)
    backtrack(&res,n,0,0,"")
    return res
}

func backtrack(res *[]string, n, openN, closedN int, val string) {
    if openN == closedN && openN == n {
        *res = append(*res, val)
        return
    }
    if openN < n {
        backtrack(res, n, openN + 1, closedN, val + "(")
    }
    if closedN < openN {
        backtrack(res, n, openN, closedN + 1, val + ")")
    }
}

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

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

import "container/heap"

type PQueue []*ListNode

func (pq PQueue) Len() int {
    return len(pq)
}

func (pq PQueue) Less(i, j int) bool {
    return pq[i].Val < pq[j].Val
}

func (pq PQueue) Swap(i, j int) {
  pq[i], pq[j] = pq[j], pq[i]
}

func (pq *PQueue) Push(x interface{}) {
  item := x.(*ListNode)
  *pq = append(*pq, item)
}

func (pq *PQueue) Pop() interface{} {
  old := *pq
  n := len(old)
  item := old[n-1]
  old[n-1] = nil
  *pq = old[0 : n-1]
  return item
}

func (pq *PQueue) Peek(x interface{}) *ListNode {
    return (*pq)[len(*pq)-1]
}

func mergeKLists(lists []*ListNode) *ListNode {
    top := &ListNode{
        Val: -1,
    }
    merged := top
    pq := PQueue{}
    for _, l := range lists {
        if l != nil {
            pq = append(pq, l)
        }
    }
    heap.Init(&pq)
    for len(pq) > 0 {
        merged.Next = heap.Pop(&pq).(*ListNode)
        merged = merged.Next
        if merged.Next != nil {
            heap.Push(&pq, merged.Next)
        }
    }
    return top.Next
}

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

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

import "container/heap"

type PQueue []*ListNode

func (pq PQueue) Len() int {
    return len(pq)
}

func (pq PQueue) Less(i, j int) bool {
    return pq[i].Val < pq[j].Val
}

func (pq PQueue) Swap(i, j int) {
  pq[i], pq[j] = pq[j], pq[i]
}

func (pq *PQueue) Push(x interface{}) {
  item := x.(*ListNode)
  *pq = append(*pq, item)
}

func (pq *PQueue) Pop() interface{} {
  old := *pq
  n := len(old)
  item := old[n-1]
  old[n-1] = nil
  *pq = old[0 : n-1]
  return item
}

func (pq *PQueue) Peek(x interface{}) *ListNode {
    return (*pq)[len(*pq)-1]
}

func mergeKLists(lists []*ListNode) *ListNode {
    top := &ListNode{
        Val: -1,
    }
    merged := top
    pq := PQueue{}
    for _, l := range lists {
        if l != nil {
            pq = append(pq, l)
        }
    }
    heap.Init(&pq)
    for len(pq) > 0 {
        merged.Next = heap.Pop(&pq).(*ListNode)
        merged = merged.Next
        if merged.Next != nil {
            heap.Push(&pq, merged.Next)
        }
    }
    return top.Next
}

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

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

import "container/heap"

type PQueue []*ListNode

func (pq PQueue) Len() int {
    return len(pq)
}

func (pq PQueue) Less(i, j int) bool {
    return pq[i].Val < pq[j].Val
}

func (pq PQueue) Swap(i, j int) {
  pq[i], pq[j] = pq[j], pq[i]
}

func (pq *PQueue) Push(x interface{}) {
  item := x.(*ListNode)
  *pq = append(*pq, item)
}

func (pq *PQueue) Pop() interface{} {
  old := *pq
  n := len(old)
  item := old[n-1]
  old[n-1] = nil
  *pq = old[0 : n-1]
  return item
}

func (pq *PQueue) Peek(x interface{}) *ListNode {
    return (*pq)[len(*pq)-1]
}

func mergeKLists(lists []*ListNode) *ListNode {
    top := &ListNode{
        Val: -1,
    }
    merged := top
    pq := PQueue{}
    for _, l := range lists {
        if l != nil {
            pq = append(pq, l)
        }
    }
    heap.Init(&pq)
    for len(pq) > 0 {
        merged.Next = heap.Pop(&pq).(*ListNode)
        merged = merged.Next
        if merged.Next != nil {
            heap.Push(&pq, merged.Next)
        }
    }
    return top.Next
}

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

func swapPairs(head *ListNode) *ListNode {
    newHead := &ListNode{
        Next: head,
    }
    prev := newHead
    i := head
    if i == nil {
        return head
    }
    j := head.Next
    for i != nil && j != nil {
        prev.Next = j
        i.Next = j.Next
        j.Next = i
        if i.Next == nil {
            break
        }
        prev, i, j = i, i.Next, i.Next.Next
    }
    return newHead.Next
}

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

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

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

func reverseKGroup(head *ListNode, k int) *ListNode {
    top := &ListNode{
        Next: head,
    }
    track := top
    for track.Next != nil {
        last, after := reverse(track.Next, k)
        if last == nil {
            return top.Next
        }
        track.Next.Next = after
        track.Next, track = last, track.Next
    }
    return top.Next
}

func reverse(n *ListNode, remaining int) (last, after *ListNode) {
    if remaining == 1 {
        return n, n.Next
    }
    if n.Next == nil {
        return nil, nil
    }
    last, after = reverse(n.Next, remaining-1)
    if last == nil {
        return nil, nil
    }
    n.Next.Next = n
    return
}

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

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

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

func removeDuplicates(nums []int) int {
    if len(nums) <= 1 {
        return len(nums)
    }
    i, j := 0, 1
    for j < len(nums) {
        if nums[i] == nums[j] {
            j++
        } else {
            nums[i+1] = nums[j]
            i++
            j++
        }
    }
    return i+1
}

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

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

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

func removeElement(a []int, val int) int {
    n := len(a)
    j := 0
    for i := 0; i<n; i++ {
        if a[i] != val {
            a[j] = a[i]
            j++
        }
    } 
    return j
}

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

func strStr(haystack string, needle string) int {
    n := len(needle)
    if n==0 {
        return 0
    }
    for i:=0; i<len(haystack)-n+1; i++ {
        if haystack[i:i+n] == 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.

func divide(dividend int, divisor int) int {
    c := 0
    dividendS, r := SplitSignAndNum(dividend)
    divisorS, d := SplitSignAndNum(divisor)
    for r >= d {
        r = r - d
        c++
    }
    
    result := c
    
    if dividendS < 0 || divisorS < 0 {
        if !(dividendS < 0 && divisorS < 0) {
            result = -c
        }
    }
    
    if result < -2147483648 {
        return -2147483648
    } else if result > 2147483647 {
        return 2147483647
    }
    
    return result
}

func SplitSignAndNum(i int) (int,int) {
    if i < 0 {
        return -1, -i
    }
    return 1, i
}

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

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

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

import "sort"

func findSubstring(s string, words []string) []int {
    sort.Strings(words)
    var result []int
    for i := range s {
        if startsWithConcatenatedSubstring(s[i:], words) {
            result = append(result, i)
        }
    }
    return result
}

func startsWithConcatenatedSubstring(s string, words []string) bool {
    var parts[] string
    wl := len(words[0])
    for i := range words {
        startPos := wl*i
        endPos := wl*(i+1)
        if endPos > len(s) {
            return false
        }
        p := s[startPos:endPos]
        parts = append(parts, p)
    }
    sort.Strings(parts)
    for i, p := range parts {
        if p != words[i] {
            return false
        }
    }
    return true
}