Перейти к содержимому
ГоМастер

Поиск по урокам

Найдите урок, курс, термин или раздел

Middle ~26 мин 9 вопросов

Задачи с собеседований Golang: 9 типовых задач с разбором и кодом

После теоретических вопросов почти в каждом интервью идёт живое кодирование: «реализуйте пул воркеров», «разверните строку», «добавьте таймаут к этому запросу». Здесь ищут не знание алгоритмов уровня LeetCode, а два практических навыка: писать конкурентный код без гонок и замечать ловушки стандартной библиотеки — руны вместо байтов, закрытие каналов, дедлоки при остановке.

Ниже — девять задач, которые реально встречаются в собеседованиях Golang, с полным кодом и разбором того, где кандидаты ломаются чаще всего. Каждая задача — это ещё и шаблон: пул воркеров превращается в ограничитель параллелизма, пайплайн — в этапы обработки данных, таймаут — в любой обёртке над внешним вызовом.

Все примеры можно запустить прямо в браузере в песочнице Go — перед интервью стоит прогнать каждый руками, а не читать глазами: в кодинге под давлением пальцы должны знать путь. Теория по конкурентности, на которой построены эти задачи, разобрана в статьях про горутины и каналы и sync-примитивы.

Как отвечать: определение → как работает внутри → где ловушка → пример. Отвечайте вслух до чтения ответа — собеседование это устный жанр, и «понимаю про себя» не равно «объясняю словами».

1. Задача 1: разверните строку («Привет» → «тевирП»). В чём ловушка?

Ловушка — байты против рун. Если строку конвертировать в []byte и развернуть, многобайтовые символы кириллицы и эмодзи разъезжаются на мусор: каждый кириллический символ занимает два байта UTF-8, и побайтовый разворот ставит байты одного символа в неправильном порядке. Правильное решение — конвертировать в []rune: рун-слайс это []rune(s) разбирает строку на кодовые точки, разворот переставляет целые символы, и string() собирает их обратно в корректный UTF-8.

func reverse(s string) string {
    r := []rune(s)
    for i, j := 0, len(r)-1; i < j; i, j = i+1, j-1 {
        r[i], r[j] = r[j], r[i]
    }
    return string(r)
}

reverse("Привет") // "тевирП" — верно
// побайтовый разворот []byte(s) ломает многобайтовые символы

2. Задача 2: реализуйте пул воркеров на N горутин с очередью задач.

Классика конкурентного кодинга. Каркас: канал задач (обычно буферизованный), N горутин-воркеров читающих из него, sync.WaitGroup для ожидания завершения, и закрытие канала задач producer-ом — это сигнал «работы больше нет», после которого воркеры выходят из range. Типичные ошибки кандидатов: забывают wg.Done (пул висит), закрывают канал из воркера (паника), не передают канал закрытия для раннего останова. На middle-уровне ждут ещё и graceful shutdown: контекст или отдельный done-канал, чтобы пул можно было остановить, не дожидаясь конца очереди.

func pool(jobs <-chan int, workers int) []int {
    results := make(chan int, workers)
    var wg sync.WaitGroup
    for i := 0; i < workers; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            for j := range jobs { // выход при close(jobs)
                results <- j * j
            }
        }(i)
    }
    go func() { wg.Wait(); close(results) }()
    var out []int
    for r := range results { out = append(out, r) }
    return out
}

3. Задача 3: оберните вызов функции таймаутом на 2 секунды.

Базовый шаблон: результат уходит в канал, а select гонит либо результат, либо time.After. Ключевая деталь, которую проверяют этим заданием: горутина с «медленной» операцией после срабатывания таймаута НЕ останавливается — select просто перестал её ждать, а горутина живёт и держит ресурсы (это утечка). Канал результата должен быть буферизованным на 1, иначе покинутая горутина навсегда заблокируется на отправке. Взрослое решение — context.WithTimeout: операция должна сама уважать ctx.Done(), тогда таймаут реально освобождает ресурсы.

func withTimeout(fn func() int, d time.Duration) (int, error) {
    ch := make(chan int, 1) // буфер обязателен!
    go func() { ch <- fn() }()
    select {
    case v := <-ch:
        return v, nil
    case <-time.After(d):
        return 0, errors.New("timeout")
    }
}

4. Задача 4: постройте пайплайн из трёх стадий (генератор → обработка → сбор).

Пайплайн — это цепочка каналов, где каждая стадия — горутина: читает из входного канала через range, преобразует, пишет в выходной, и на выходе из range (вход закрыт) закрывает свой выходной канал. Закрытие протекает по цепочке: закрыли источник — закрылась первая стадия — закрылась вторая — читатель collection-цикла завершился. Так interviewer проверяет понимание «кто владеет каналом — тот и закрывает». Ловушка: если промежуточные каналы небуферизованные, пайплайн работает в темпе самой медленной стадии — это фича (backpressure), а не баг, но о ней надо сказать словами.

func generate(nums ...int) <-chan int {
    out := make(chan int)
    go func() {
        defer close(out)
        for _, n := range nums { out <- n }
    }()
    return out
}

func square(in <-chan int) <-chan int {
    out := make(chan int)
    go func() {
        defer close(out)
        for n := range in { out <- n * n }
    }()
    return out
}

5. Задача 5: реализуйте LRU-кэш с O(1) на get и put.

Стандартное решение — map для доступа по ключу плюс двусвязный список для порядка использования: map[string]*list.Element. При get элемент перемещается в голову списка (PushFront после Remove), при переполнении удаляется хвост (Back). В Go это container/list — собеседовать не ждут реализацию списка с нуля, но ждут понимания, почему map без списка не даёт порядок, а слайс вместо списка делает операции O(n). Ловушка на внимательность: list.Remove возвращает значение типа any — перед записью в map нужен type assertion. Для продвинутых: уточнить про потокобезопасность — обёртка sync.Mutex, либо озвучить sync.Map и его ограничения.

type LRU struct {
    cap  int
    m    map[string]*list.Element
    l    *list.List
}

type entry struct{ key, val string }

func (c *LRU) Get(k string) (string, bool) {
    if el, ok := c.m[k]; ok {
        c.l.MoveToFront(el)
        return el.Value.(entry).val, true
    }
    return "", false
}

func (c *LRU) Put(k, v string) {
    if el, ok := c.m[k]; ok {
        el.Value = entry{k, v}
        c.l.MoveToFront(el)
        return
    }
    c.m[k] = c.l.PushFront(entry{k, v})
    if c.l.Len() > c.cap {
        last := c.l.Back()
        delete(c.m, last.Value.(entry).key)
        c.l.Remove(last)
    }
}

6. Задача 6: объедините результаты двух горутин в один канал (fan-in).

Fan-in — зеркальная задача к пайплайну: два потока данных собираются в один. Простое решение для двух каналов — две горутины-релея пишут в общий канал, sync.WaitGroup закрывает общий канал после обеих. Обобщение на N каналов — reflect.Select или рекурсивный merge, но на собеседовании это редко успевают: важнее назвать проблему «кто закрывает общий канал» — только после того, как закрылись все источники, иначе читатель получит неполные данные или панику. Второй момент: общий канал стоит сделать буферизованным на сумму ёмкостей источников, если нужна скорость, а не строго темповая передача.

func fanIn(a, b <-chan int) <-chan int {
    out := make(chan int, cap(a)+cap(b))
    var wg sync.WaitGroup
    relay := func(src <-chan int) {
        defer wg.Done()
        for v := range src { out <- v }
    }
    wg.Add(2)
    go relay(a)
    go relay(b)
    go func() { wg.Wait(); close(out) }()
    return out
}

7. Задача 7: напишите rate limiter — не более 3 запросов в секунду.

Простейшая версия на time.Ticker: тикер тикает 3 раза в секунду, и каждый запрос ждёт своего тика — token bucket по сути. В энтерпрайз-версии ждут либо golang.org/x/time/rate (Limiter с Wait(ctx) — рассказывает о burst и лимитах), либо собственный токен-бакет: слайс/канал токенов пополняется таймером, потребители читают non-blocking select. Проверяют два понимания: (1) rate limiter ограничивает СКОРОСТЬ, а не параллелизм — для параллелизма нужен семафор (chan struct{} ёмкостью N); (2) при остановке сервиса тикер надо остановить (ticker.Stop()), иначе утечка. Упоминание «на практике возьму x/time/rate, руками напишу только если зависимости запрещены» — правильный ответ, а не слабость.

func newLimiter(perSec int) func() {
    ticks := time.NewTicker(time.Second / time.Duration(perSec))
    return func() {
        <-ticks.C // ждём своего тика
    }
}

limiter := newLimiter(3)
for i := 0; i < 10; i++ {
    limiter()
    fmt.Println("запрос", i, time.Now().Format("15:04:05.000"))
}

8. Задача 8: найдите первый неповторяющийся символ строки (за один проход? за два?).

Решение за два прохода: первый проход строит map[rune]int со счётчиками, второй ищет первую руну с счётчиком 1 — O(n) по времени и памяти. Обязательные уточнения, за которые дают плюс: работа с рунами, а не байтами (кириллица, эмодзи); сложность честная — map даёт O(1) в среднем, но константа заметная; для ASCII-строк вместо map эффективнее массив на 128 элементов. Если интервьюер давит «за один проход и O(1) памяти» — это либо подвох (такая задача в общем виде не решается), либо строка из ограниченного алфавита с битовой маской. Умение сказать «в общем виде нельзя, вот почему» ценится выше, чем выдумывание псевдорешения.

func firstUnique(s string) (rune, bool) {
    count := make(map[rune]int)
    for _, r := range s { count[r]++ }
    for _, r := range s {
        if count[r] == 1 { return r, true }
    }
    return 0, false
}

9. Задача 9: остановите пул воркеров по сигналу и дождитесь завершения текущих задач (graceful shutdown).

Шаблон трёх слоёв: (1) канал остановки (context или done-канал) — воркеры проверяют ctx.Done() в select между задачами и в начале цикла; (2) WaitGroup — главный поток wg.Wait() дожидается, пока воркеры дообработают текущую задачу и выйдут; (3) producer перестаёт класть задачи при том же ctx. Проверяют именно различие: «немедленно убить» (закрыть done) и «дообработать и выйти» — не одно и то же, и смешивать их нельзя. В проде это оборачивается в http.Server.Shutdown(ctx) с таймаутом: не дождались в отведённое время — принудительный выход. Упоминание signal.NotifyContext(os.Interrupt, syscall.SIGTERM) показывает знание боевой схемы запуска и остановки сервиса.

ctx, cancel := context.WithCancel(context.Background())
var wg sync.WaitGroup
for i := 0; i < 3; i++ {
    wg.Add(1)
    go func() {
        defer wg.Done()
        for {
            select {
            case <-ctx.Done():
                return // стоп: текущая задача уже дообработана
            case j := <-jobs:
                process(j)
            }
        }
    }()
}
// на SIGTERM: cancel(); wg.Wait()

Прокачать тему в самоучителе

Читается быстро, запоминается практикой. Эти курсы закрывают тему с запуском кода прямо на странице: