uk
Feedback

Не попадись на ботовода! Telemetrio знаходить і позначає такі канали мітками 👉 Хочеш бачити мітку, оформляй підписку

Golang | LeetCode

Golang | LeetCode

Відкрити в Telegram

Сайт: https://easyoffer.ru/ Все каналы: t.me/+xGeAw6ckJ4liYzQy Контакт для рекламы: @sendme_ads

Показати більше
3 510
Підписники
-224 години
-87 днів
-4930 днів
Архів дописів
Задача: 1160. Find Words That Can Be Formed by Characters Сложность: easy Вам дан массив строк words и строка chars. Строка считается хорошей, если она может быть составлена из символов chars (каждый символ может быть использован только один раз). Верните сумму длин всех хороших строк в words. Пример:
Input: words = ["cat","bt","hat","tree"], chars = "atach"
Output: 6
Explanation: The strings that can be formed are "cat" and "hat" so the answer is 3 + 3 = 6.
👨‍💻 Алгоритм: 1⃣Создайте хеш-таблицу counts, которая будет записывать частоту каждого символа в chars. Инициализируйте переменную ans = 0. 2⃣Итерируйте по каждому слову в words. Создайте хеш-таблицу wordCount, которая будет записывать частоту каждого символа в слове. Установите good = true. Итерируйте по каждому ключу c в wordCount. Пусть freq = wordCount[c]. Если counts[c] < freq, установите good = false и прервите цикл. 3⃣Если good = true, добавьте длину слова к ans. Верните ans. 😎 Решение
func countCharacters(words []string, chars string) int {
    counts := make(map[rune]int)
    for _, c := range chars {
        counts[c]++
    }
    
    ans := 0
    for _, word := range words {
        wordCount := make(map[rune]int)
        for _, c := range word {
            wordCount[c]++
        }
        
        good := true
        for c, freq := range wordCount {
            if counts[c] < freq {
                good = false
                break
            }
        }
        
        if good {
            ans += len(word)
        }
    }
    
    return ans
}
Ставь 👍 и забирай 📚 Базу знаний

Задача: 895. Maximum Frequency Stack Сложность: hard Разработайте структуру данных, похожую на стек, чтобы заталкивать элементы в стек и вытаскивать из него самый частый элемент. Реализуйте класс FreqStack: FreqStack() строит пустой стек частот. void push(int val) заталкивает целое число val на вершину стека. int pop() удаляет и возвращает самый частый элемент в стеке. Если есть равенство в выборе самого частого элемента, то удаляется и возвращается элемент, который ближе всего к вершине стека. Пример:
Input
["FreqStack", "push", "push", "push", "push", "push", "push", "pop", "pop", "pop", "pop"]
[[], [5], [7], [5], [7], [4], [5], [], [], [], []]
Output
[null, null, null, null, null, null, null, 5, 7, 5, 4]
👨‍💻 Алгоритм: 1⃣Создать два словаря: freq для хранения частоты каждого элемента и group для хранения стека элементов для каждой частоты. 2⃣При добавлении элемента увеличивать его частоту в freq и добавлять его в стек соответствующей частоты в group. 3⃣При извлечении элемента найти максимальную частоту, удалить элемент из стека соответствующей частоты и уменьшить его частоту в freq. Если стек для данной частоты становится пустым, удалить его. 😎 Решение:
package main

type FreqStack struct {
    freq    map[int]int
    group   map[int][]int
    maxfreq int
}

func Constructor() FreqStack {
    return FreqStack{
        freq:  make(map[int]int),
        group: make(map[int][]int),
    }
}

func (this *FreqStack) Push(val int) {
    f := this.freq[val] + 1
    this.freq[val] = f
    if f > this.maxfreq {
        this.maxfreq = f
    }
    this.group[f] = append(this.group[f], val)
}

func (this *FreqStack) Pop() int {
    vals := this.group[this.maxfreq]
    val := vals[len(vals)-1]
    this.group[this.maxfreq] = vals[:len(vals)-1]
    this.freq[val]--
    if len(this.group[this.maxfreq]) == 0 {
        this.maxfreq--
    }
    return val
}
Ставь 👍 и забирай 📚 Базу знаний

Задача: 744. Find Smallest Letter Greater Than Target Сложность: easy Нам дан массив символов letters, отсортированный в неубывающем порядке, и символ target. В массиве letters есть как минимум два разных символа. Возвращается наименьший символ в letters, который лексикографически больше target. Если такого символа не существует, возвращается первый символ в буквах. Пример:
Input: letters = ["c","f","j"], target = "a"
Output: "c"
👨‍💻 Алгоритм: 1⃣Использовать бинарный поиск для нахождения позиции первого символа в letters, который лексикографически больше target. 2⃣Если найденный символ существует, вернуть его. 3⃣Если такого символа не существует, вернуть первый символ в letters. 😎 Решение:
package main

func nextGreatestLetter(letters []byte, target byte) byte {
    left, right := 0, len(letters)-1
    for left <= right {
        mid := (left + right) / 2
        if letters[mid] > target {
            right = mid - 1
        } else {
            left = mid + 1
        }
    }
    return letters[left % len(letters)]
}
Ставь 👍 и забирай 📚 Базу знаний

Задача: 990. Satisfiability of Equality Equations Сложность: medium Дан массив строк equations, представляющий отношения между переменными, где каждая строка equations[i] имеет длину 4 и принимает одну из двух форм: "xi==yi" или "xi!=yi". Здесь xi и yi - это строчные буквы (не обязательно разные), представляющие имена переменных из одной буквы. Верните true, если возможно назначить целые числа именам переменных таким образом, чтобы удовлетворить всем заданным уравнениям, или false в противном случае. Пример:
Input: equations = ["b==a","a==b"]
Output: true
Explanation: We could assign a = 1 and b = 1 to satisfy both equations.
👨‍💻 Алгоритм: 1⃣Создание графа для уравнений "==": Создайте структуру данных для объединения (Union-Find) для обработки уравнений равенства. Пройдите через массив equations и для каждого уравнения типа "xi==yi" объедините соответствующие переменные. 2⃣Проверка уравнений "!=": Пройдите через массив equations и для каждого уравнения типа "xi!=yi" проверьте, принадлежат ли переменные к одной и той же группе в структуре объединения. Если принадлежат, верните false. 3⃣Возврат результата: Если после проверки всех уравнений "xi!=yi" не было обнаружено противоречий, верните true. 😎 Решение:
func equationsPossible(equations []string) bool {
    uf := NewUnionFind(26)
    
    for _, eq := range equations {
        if eq[1] == '=' {
            x := int(eq[0] - 'a')
            y := int(eq[3] - 'a')
            uf.Union(x, y)
        }
    }
    
    for _, eq := range equations {
        if eq[1] == '!' {
            x := int(eq[0] - 'a')
            y := int(eq[3] - 'a')
            if uf.Connected(x, y) {
                return false
            }
        }
    }
Ставь 👍 и забирай 📚 Базу знаний

Задача: 1437. Check If All 1's Are at Least Length K Places Away Сложность: easy Дан бинарный массив nums и целое число k. Вернуть true, если все единицы находятся на расстоянии не менее k позиций друг от друга, в противном случае вернуть false. Пример:
Input: nums = [1,0,0,0,1,0,0,1], k = 2
Output: true
Explanation: Each of the 1s are at least 2 places away from each other.
👨‍💻 Алгоритм: 1⃣Инициализировать счетчик нулей значением k для учета первого появления единицы. 2⃣Итерировать по массиву nums, проверяя, если текущий элемент равен 1. Если число нулей между единицами меньше k, вернуть false; иначе сбросить счетчик нулей на 0. 3⃣Если текущий элемент равен 0, увеличить счетчик нулей. В конце итерации вернуть true. 😎 Решение:
func kLengthApart(nums []int, k int) bool {
    count := k
    for _, num := range nums {
        if num == 1 {
            if count < k {
                return false
            }
            count = 0
        } else {
            count++
        }
    }
    return true
}
Ставь 👍 и забирай 📚 Базу знаний

Задача: 785. Is Graph Bipartite? Сложность: medium Есть неориентированный граф с n узлами, где каждый узел пронумерован от 0 до n - 1. Вам дан двумерный массив graph, где graph[u] — это массив узлов, смежных с узлом u. Более формально, для каждого v в graph[u] существует неориентированное ребро между узлом u и узлом v. Граф обладает следующими свойствами: Нет петель (graph[u] не содержит u). Нет параллельных ребер (graph[u] не содержит дублирующихся значений). Если v есть в graph[u], то u есть в graph[v] (граф неориентированный). Граф может быть несвязным, то есть могут существовать два узла u и v, между которыми нет пути. Граф является двудольным, если узлы можно разделить на два независимых множества A и B так, что каждое ребро в графе соединяет узел из множества A с узлом из множества B. Верните true, если и только если граф является двудольным. Пример:
Input: graph = [[1,2,3],[0,2],[0,1,3],[0,2]]
Output: false
Explanation: There is no way to partition the nodes into two independent sets such that every edge connects a node in one and a node in the other.
👨‍💻 Алгоритм: 1⃣Мы будем хранить массив (или hashmap) для поиска цвета каждого узла: color[node]. Цвета могут быть 0, 1 или неокрашенные (-1 или null). 2⃣Мы должны быть внимательны к рассмотрению несвязных компонентов графа, выполняя поиск для каждого узла. Для каждого неокрашенного узла мы начнем процесс окрашивания, выполняя поиск в глубину (DFS) для этого узла. Каждый соседний узел получает цвет, противоположный цвету текущего узла. Если мы обнаруживаем, что соседний узел окрашен в тот же цвет, что и текущий узел, значит, наше окрашивание невозможно. 3⃣Для выполнения поиска в глубину мы используем стек. Для каждого неокрашенного соседа в graph[node] мы будем его окрашивать и добавлять в наш стек, который действует как своего рода "список дел" для узлов, которые нужно посетить дальше. Наш внешний цикл для start... гарантирует, что мы окрасим каждый узел. 😎 Решение:
func isBipartite(graph [][]int) bool {
    color := make(map[int]int)
    for node := 0; node < len(graph); node++ {
        if _, found := color[node]; !found {
            stack := []int{node}
            color[node] = 0
            for len(stack) > 0 {
                currentNode := stack[len(stack)-1]
                stack = stack[:len(stack)-1]
                for _, neighbor := range graph[currentNode] {
                    if _, found := color[neighbor]; !found {
                        stack = append(stack, neighbor)
                        color[neighbor] = color[currentNode] ^ 1
                    } else if color[neighbor] == color[currentNode] {
                        return false
                    }
                }
            }
        }
    }
    return true
}
Ставь 👍 и забирай 📚 Базу знаний

Задача: 1209. Remove All Adjacent Duplicates in String II Сложность: medium Вам дана строка s и целое число k. Удаление k дубликатов состоит в выборе k соседних и одинаковых букв из s и их удалении, что приводит к соединению левой и правой части удаленной подстроки вместе. Мы повторяем удаление k дубликатов в s до тех пор, пока не сможем больше этого сделать. Верните итоговую строку после всех таких удалений дубликатов. Гарантируется, что ответ уникален. Пример:
Input: s = "deeedbbcccbdaa", k = 3
Output: "aa"
Explanation: 
First delete "eee" and "ccc", get "ddbbbdaa"
Then delete "bbb", get "dddaa"
Finally delete "ddd", get "aa"
👨‍💻 Алгоритм: 1⃣Инициализировать медленный указатель j значением 0 и стек counts для хранения количества одинаковых символов. 2⃣Перемещать быстрый указатель i по строке s: Копировать s[i] в s[j]. Если s[j] совпадает с s[j - 1], увеличить значение на вершине стека. Иначе добавить 1 в стек. Если количество символов равно k, уменьшить j на k и извлечь из стека. 3⃣Вернуть первые j символов строки. 😎 Решение:
func removeDuplicates(s string, k int) string {
    counts := []int{}
    sa := []rune(s)
    j := 0
    
    for i := 0; i < len(sa); i++ {
        sa[j] = sa[i]
        if j == 0 || sa[j] != sa[j-1] {
            counts = append(counts, 1)
        } else {
            incremented := counts[len(counts)-1] + 1
            counts = counts[:len(counts)-1]
            if incremented == k {
                j -= k
            } else {
                counts = append(counts, incremented)
            }
        }
        j++
    }
    return string(sa[:j])
}
Ставь 👍 и забирай 📚 Базу знаний

Задача: 1416. Restore The Array Сложность: hard Программа должна была напечатать массив целых чисел. Программа забыла напечатать пробелы, и массив напечатан как строка цифр s, и всё, что мы знаем, это что все числа в массиве были в диапазоне [1, k] и в массиве нет ведущих нулей. Учитывая строку s и целое число k, верните количество возможных массивов, которые могут быть напечатаны как s с использованием упомянутой программы. Так как ответ может быть очень большим, верните его по модулю 10^9 + 7. Пример:
Input: s = "1000", k = 10000
Output: 1
Explanation: The only possible array is [1000]
👨‍💻 Алгоритм: 1⃣Создать массив dp размера m + 1, чтобы хранить значения dfs(x). 2⃣Для получения значения dfs(start), если dp[start] не равно нулю, вернуть его значение. Иначе: Если s[start] == 0, вернуть 0. Если start = m, вернуть 1. Инициализировать count = 0, чтобы считать количество возможных массивов. Перебрать все возможные конечные индексы end, и если s[start ~ end] представляет допустимое число, продолжить рекурсивный вызов dfs(end + 1) и обновить count как count += dfs(end + 1). Обновить dp[start] значением dfs(start). 3⃣Вернуть dfs(0). 😎 Решение:
func dfs(dp []int, start int, s string, k int) int {
    if dp[start] != 0 {
        return dp[start]
    }
    if start == len(s) {
        return 1
    }
    if s[start] == '0' {
        return 0
    }

    mod := 1_000_000_007
    count := 0
    for end := start; end < len(s); end++ {
        currNumber, _ := strconv.Atoi(s[start : end+1])
        if currNumber > k {
            break
        }
        count = (count + dfs(dp, end+1, s, k)) % mod
    }

    dp[start] = count
    return count
}

func numberOfArrays(s string, k int) int {
    dp := make([]int, len(s)+1)
    return dfs(dp, 0, s, k)
}
Ставь 👍 и забирай 📚 Базу знаний

Задача: 412. Fizz Buzz Сложность: easy Учитывая целое число n, верните строковый массив answer (с индексом 1), где: answer[i] == "FizzBuzz", если i делится на 3 и 5. answer[i] == "Fizz", если i делится на 3. answer[i] == "Buzz", если i делится на 5. answer[i] == i (как строка), если ни одно из перечисленных условий не верно. Пример:
Input: nums = [1,2,2]
Output: [[],[1],[1,2],[1,2,2],[2],[2,2]]
👨‍💻 Алгоритм: 1⃣Создайте пустой список для хранения результата. 2⃣Пройдите по всем числам от 1 до n и для каждого числа выполните проверку: Если число делится на 3 и на 5, добавьте "FizzBuzz". Если число делится на 3, добавьте "Fizz". Если число делится на 5, добавьте "Buzz". Если ни одно из условий не выполнено, добавьте само число как строку. 3⃣Верните полученный список. 😎 Решение:
package main

import (
    "strconv"
)

func fizzBuzz(n int) []string {
    answer := make([]string, n)
    for i := 1; i <= n; i++ {
        switch {
        case i % 3 == 0 && i % 5 == 0:
            answer[i-1] = "FizzBuzz"
        case i % 3 == 0:
            answer[i-1] = "Fizz"
        case i % 5 == 0:
            answer[i-1] = "Buzz"
        default:
            answer[i-1] = strconv.Itoa(i)
        }
    }
    return answer
}
Ставь 👍 и забирай 📚 Базу знаний

Задача: №57. Insert Interval Сложность: medium Вам дан массив непересекающихся интервалов intervals, где intervals[i] = [starti, endi] представляет начало и конец i-го интервала, и массив intervals отсортирован в порядке возрастания по starti. Вам также дан интервал newInterval = [start, end], представляющий начало и конец другого интервала. Вставьте newInterval в массив intervals так, чтобы intervals оставался отсортированным в порядке возрастания по starti и в intervals не было бы перекрывающихся интервалов (при необходимости объедините перекрывающиеся интервалы). Верните массив intervals после вставки. Обратите внимание, что не обязательно модифицировать массив intervals на месте. Вы можете создать новый массив и вернуть его. Пример:
Input: intervals = [[1,3],[6,9]], newInterval = [2,5]
Output: [[1,5],[6,9]]
👨‍💻 Алгоритм: 1⃣Инициализация переменных: Инициализируются переменные n и i для хранения размера массива интервалов и текущего индекса соответственно, а также пустой массив res для хранения результата. 2⃣Обработка случаев без перекрытия и с перекрытием: В случае отсутствия перекрытия до вставки, проходим через массив интервалов до тех пор, пока конечная точка текущего интервала меньше начальной точки нового интервала. Добавляем текущий интервал в массив res и переходим к следующему. В случае перекрытия, продолжаем обход, пока начальная точка нового интервала меньше или равна конечной точке текущего интервала. Обновляем начальные и конечные точки нового интервала, объединяя перекрывающиеся интервалы в один. 3⃣Обработка интервалов после вставки: Проходим через оставшиеся интервалы после индекса i и добавляем их в массив res. Это включает интервалы, которые следуют после нового интервала и не перекрываются с ним. Возвращаем массив res, содержащий все интервалы с корректно вставленным новым интервалом. 😎 Решение:
func insert(intervals [][]int, newInterval []int) [][]int {
    n := len(intervals)
    i := 0
    res := make([][]int, 0)

    for i < n && intervals[i][1] < newInterval[0] {
        res = append(res, intervals[i])
        i++
    }

    for i < n && newInterval[1] >= intervals[i][0] {
        newInterval[0] = min(newInterval[0], intervals[i][0])
        newInterval[1] = max(newInterval[1], intervals[i][1])
        i++
    }
    res = append(res, newInterval)

    for i < n {
        res = append(res, intervals[i])
        i++
    }

    return res
}

func min(x, y int) int {
    if x < y {
        return x
    }
    return y
}

func max(x, y int) int {
    if x > y {
        return x
    }
    return y
}
Ставь 👍 и забирай 📚 Базу знаний

🔥 Скрытые вакансии с удаленной работой для Golang разработчика, которые нигде больше не публикуются. Напрямую от компаний, с
🔥 Скрытые вакансии с удаленной работой для Golang разработчика, которые нигде больше не публикуются. Напрямую от компаний, с контактами рекрутеров. 🔹 Golang Go Jobs | Вакансии 🔸 Все каналы с вакансиями

Задача: 1315. Sum of Nodes with Even-Valued Grandparent Сложность: medium Given the root of a binary tree, return the sum of values of nodes with an even-valued grandparent. If there are no nodes with an even-valued grandparent, return 0. A grandparent of a node is the parent of its parent if it exists. Пример:
Input: root = [6,7,8,2,7,1,3,9,null,1,4,null,null,null,5]
Output: 18
Explanation: The red nodes are the nodes with even-value grandparent while the blue nodes are the even-value grandparents.
👨‍💻 Алгоритм: 1⃣Определите метод solve(), который принимает TreeNode root, значение родителя parent и значение бабушки или дедушки gParent. Этот метод возвращает сумму значений узлов с четным значением бабушки и дедушки в поддереве узла root. Если root равен null, верните 0 как сумму. 2⃣Рекурсивно пройдите по левому и правому дочерним узлам, передавая в качестве значения parent root, а в качестве значения gParent parent. Если значение gParent четное, добавьте значение root к ответу. 3⃣Вызовите рекурсивную функцию solve() с корневым узлом и значениями -1 для parent и gParent. Верните сумму для левого и правого дочерних узлов и значение для текущего узла. 😎 Решение
func solve(root *TreeNode, parent, gParent int) int {
    if root == nil {
        return 0
    }
    return solve(root.Left, root.Val, parent) + solve(root.Right, root.Val, parent) + func() int {
        if gParent%2 == 0 {
            return root.Val
        }
        return 0
    }()
}

func sumEvenGrandparent(root *TreeNode) int {
    return solve(root, -1, -1)
}
Ставь 👍 и забирай 📚 Базу знаний

🎓 Тестовый собес с CTO Reactive Apps [+ эталонные ответы на 50 сложных вопросов в подарок] В четверг, 5 ноября, в 19:00 мск
🎓 Тестовый собес с CTO Reactive Apps [+ эталонные ответы на 50 сложных вопросов в подарок] В четверг, 5 ноября, в 19:00 мск приходи онлайн на открытый Go-собес. Увидишь, как проверяют технические знания кандидатов, и сможешь оценить свою готовность к такому формату. 👤 Интервьюер: Дима Дорофеев, CTO Reactive Apps Как всё будет:
📂 Дима проведёт собес с разработчиком-добровольцем и предложит ему вопросы и задачи из реальных технических интервью. Участник не будет знать их заранее 📂 После каждого ответа разберёт его сильные и слабые стороны и объяснит, что важно для интервьюера 📂 В конце сможешь задать Диме свои вопросы и получить развёрнутые ответы
Эфир проходит в рамках менторской программы ШОРТКАТ для Go-разработчиков, которые хотят сменить работу, вырасти в грейде и зарплате 🎁 За регистрацию подарим файл с эталонными ответами на 50 сложных вопросов с Go-собеседований Переходи в бота, чтобы зарегистрироваться на эфир и забрать подарок 👉 @shortcut_go_bot Реклама. О рекламодателе.

Задача: 1036. Escape a Large Maze Сложность: hard Имеется сетка размером 1 миллион на 1 миллион на плоскости XY, координаты каждого квадрата сетки - (x, y). Мы начинаем с исходного квадрата = [sx, sy] и хотим достичь цели = [tx, ty]. Существует также массив заблокированных квадратов, где каждый заблокированный[i] = [xi, yi] представляет собой заблокированный квадрат с координатами (xi, yi). Каждый ход мы можем пройти один квадрат на север, восток, юг или запад, если квадрат не находится в массиве заблокированных квадратов. Нам также не разрешается выходить за пределы сетки. Возвращается true тогда и только тогда, когда можно достичь целевого квадрата из исходного квадрата с помощью последовательности правильных ходов. Пример:
Input: blocked = [[0,1],[1,0]], source = [0,0], target = [0,2]
Output: false
👨‍💻 Алгоритм: 1⃣Обработка входных данных: Загрузите координаты исходного квадрата sx, sy, целевого квадрата tx, ty и список заблокированных квадратов blocked. 2⃣Проверка простого случая: Если список blocked пуст, верните true, так как путь не будет заблокирован. Проверка начальной или целевой клетки: Если исходная или целевая клетка заблокированы, верните false. 3⃣Поиск пути с использованием BFS или DFS: Используйте алгоритм поиска в ширину (BFS) или поиска в глубину (DFS) для поиска пути от sx, sy до tx, ty, избегая заблокированных клеток. Если обнаружен путь, верните true, в противном случае верните false. 😎 Решение:
func isEscapePossible(blocked [][]int, source []int, target []int) bool {
    blockedSet := make(map[[2]int]struct{})
    for _, b := range blocked {
        blockedSet[[2]int{b[0], b[1]}] = struct{}{}
    }
    src := [2]int{source[0], source[1]}
    tgt := [2]int{target[0], target[1]}
    
    if _, found := blockedSet[src]; found || _, found := blockedSet[tgt]; found {
        return false
    }

    directions := [][2]int{{0, 1}, {1, 0}, {0, -1}, {-1, 0}}
    maxArea := len(blocked) * (len(blocked) - 1) / 2
    
    bfs := func(start, end [2]int) bool {
        queue := [][2]int{start}
        visited := map[[2]int]struct{}{start: {}}
        
        for len(queue) > 0 {
            if len(visited) > maxArea {
                return true
            }
            cur := queue[0]
            queue = queue[1:]
            for _, dir := range directions {
                next := [2]int{cur[0] + dir[0], cur[1] + dir[1]}
                if next[0] >= 0 && next[0] < 1_000_000 && next[1] >= 0 && next[1] < 1_000_000 {
                    if _, found := visited[next]; !found {
                        if _, found := blockedSet[next]; !found {
                            if next == end {
                                return true
                            }
                            queue = append(queue, next)
                            visited[next] = struct{}{}
                        }
                    }
                }
            }
        }
        return false
    }
    
    return bfs(src, tgt) && bfs(tgt, src)
}
Ставь 👍 и забирай 📚 Базу знаний

🚨 40 минут Пожизненный PRO по цене года закрывается прямо сейчас. Это последнее напоминание. 👉 https://easyoffer.ru/pro
🚨 40 минут Пожизненный PRO по цене года закрывается прямо сейчас. Это последнее напоминание. 👉 https://easyoffer.ru/pro

🎃 3 часа до полуночи... Ровно в 00:00 предложение исчезнет, как призрак на рассвете 👻 Последний шанс забрать PRO навсегда п
🎃 3 часа до полуночи... Ровно в 00:00 предложение исчезнет, как призрак на рассвете 👻 Последний шанс забрать PRO навсегда по цене одного года. Без продлений и без воскрешений. Если откладывал — не дай этой возможности стать твоим ночным кошмаром 🦇 👉 https://easyoffer.ru/pro

Задача: 746. Min Cost Climbing Stairs Сложность: easy Вам дан целочисленный массив cost, где cost[i] - стоимость i-й ступеньки на лестнице. После оплаты стоимости вы можете подняться на одну или две ступеньки. Вы можете начать со ступеньки с индексом 0 или со ступеньки с индексом 1. Верните минимальную стоимость достижения вершины этажа. Пример:
Input: cost = [10,15,20]
Output: 15
👨‍💻 Алгоритм: 1⃣Создать массив dp, где dp[i] хранит минимальную стоимость достижения i-й ступеньки. 2⃣Инициализировать dp[0] и dp[1] как cost[0] и cost[1] соответственно. Заполнить dp используя минимальную стоимость подъема с предыдущих ступенек. 3⃣Вернуть минимальную стоимость достижения вершины. 😎 Решение:
package main

func minCostClimbingStairs(cost []int) int {
    n := len(cost)
    dp := make([]int, n)
    copy(dp, cost)
    for i := 2; i < n; i++ {
        dp[i] += min(dp[i-1], dp[i-2])
    }
    return min(dp[n-1], dp[n-2])
}

func min(a, b int) int {
    if a < b {
        return a
    }
    return b
}
Ставь 👍 и забирай 📚 Базу знаний

🕯 Страшилка на ночь Год спустя. Финальный этап собеседования. В комнате становится холодно. Интервьюер медленно наклоняется
🕯 Страшилка на ночь Год спустя. Финальный этап собеседования. В комнате становится холодно. Интервьюер медленно наклоняется и шепчет: «Почему вы ушли с прошлого места работы?» Ты открываешь easyoffer, а там… «Ваша подписка истекла» 💀 Чтобы эта история не стала твоей, забери пожизненный PRO по цене одного года. База собесов, эталонные ответы, автоотклики, тренажёры и всё, что появится дальше, остаются с тобой навсегда. ⏳ Осталось 7 часов. В полночь предложение исчезнет. 👉 https://easyoffer.ru/pro

⏳ Сегодня последний день Платишь один раз и забираешь весь easyoffer навсегда, вместе со всеми будущими фичами проекта. Никак
⏳ Сегодня последний день Платишь один раз и забираешь весь easyoffer навсегда, вместе со всеми будущими фичами проекта. Никаких ежегодных продлений, только ты, твой оффер и мешок конфет 🍭 🎃 Завтра цена вернётся к обычной, и такого угощения уже не будет. 👉 https://easyoffer.ru/pro

Задача: 848. Shifting Letters Сложность: medium Вам дана строка s из строчных букв английского алфавита и целочисленный массив shifts такой же длины. Назовем shift() буквы следующей буквой в алфавите (с переходом так, что 'z' становится 'a'). Например, shift('a') = 'b', shift('t') = 'u', и shift('z') = 'a'. Теперь для каждого shifts[i] = x мы хотим сдвинуть первые i + 1 букв строки s на x раз. Верните итоговую строку после применения всех таких сдвигов к s. Пример:
Input: s = "abc", shifts = [3,5,9]
Output: "rpl"
Explanation: We start with "abc".
After shifting the first 1 letters of s by 3, we have "dbc".
After shifting the first 2 letters of s by 5, we have "igc".
After shifting the first 3 letters of s by 9, we have "rpl", the answer.
👨‍💻 Алгоритм: 1⃣Вычислите общее количество сдвигов для всех символов строки, используя массив shifts. 2⃣Пройдите по строке s и примените вычисленные сдвиги к каждому символу, начиная с первого и уменьшая количество сдвигов на текущем шаге. 3⃣Постройте и верните итоговую строку после всех сдвигов. 😎 Решение:
func shiftingLetters(s string, shifts []int) string {
    totalShifts := 0
    for _, shift := range shifts {
        totalShifts = (totalShifts + shift) % 26
    }

    result := make([]byte, len(s))
    for i := 0; i < len(s); i++ {
        newCharValue := (int(s[i]-'a') + totalShifts) % 26
        result[i] = byte(newCharValue + 'a')
        totalShifts = (totalShifts - shifts[i] + 26) % 26
    }

    return string(result)
}
Ставь 👍 и забирай 📚 Базу знаний