🧩 Алгоритмическая задача: "Почти уникальные подстроки"

📜 Условие:

Дана строка s длиной до 2⋅10⁵, содержащая только строчные буквы латинского алфавита.
Нужно найти максимальную длину `L`, такую что существует строка длины `L`, встречающаяся всего один раз в s.

🔍 Пример:

s = "ababcab"
Уникальные подстроки:
  длины 1: "c" ✅
  длины 2: "ca" ✅
  длины 3: "cab" ✅
  длины 4: "abca" ✅
Но, например, "ab" встречается дважды.

Ответ: 4

⚠️ Ограничения:

- Длина строки: до 200000
- Время — не более 1 секунды
- Нельзя использовать map[string]int наивно — будет слишком медленно
- Решение должно работать за O(n log n) или O(n) с префикс-хэшами

💡 Подсказки:

- Используй **rolling hash (polynomial hashing)** — префиксный хэш + бинарный поиск по длине `L`.
- Сначала бинарный поиск по длине: `left = 1`, `right = len(s)`
- Для каждой длины — собрать все хэши и проверить, есть ли хэш с ровно одним вхождением
- Возможна коллизия — используйте **двойной хэш** или `uint64` с Mersenne prime

✅ Что проверяет задача:

- Умение применять двухфазные алгоритмы (бинарный поиск + проверка условия)
- Навыки работы с rolling hash / префикс-хэшами
- Знание тонкостей коллизий и оптимизации по памяти

Пиши решение в комментариях

🐹 Задача для Go 1.21+: «Контекст отменён, но горутина продолжает работу»

📌 Актуально для: Go 1.21 и новее (введён `context.WithCancelCause`)
🎯 Цель: Понять, почему горутина не завершилась по отменённому контексту

📍 Ситуация:

Ты используешь контекст для управления жизненным циклом горутины. В Go 1.21 ты решил использовать context.WithCancelCause:

package main

import (
    "context"
    "fmt"
    "time"
)

func main() {
    ctx, cancel := context.WithCancelCause(context.Background())
    go worker(ctx)

    time.Sleep(1 * time.Second)
    cancel(fmt.Errorf("manual stop"))

    time.Sleep(2 * time.Second)
}

func worker(ctx context.Context) {
    <-ctx.Done()
    fmt.Println("Worker stopped:", context.Cause(ctx))
}

🔍 Ты ожидаешь, что горутина завершится и выведет:

Worker stopped: manual stop

Но вместо этого — программа завершилась без вывода. Почему?

🧩 Вопросы:

1. Почему worker не печатает "Worker stopped: ..."?
2. Что изменилось в context.WithCancelCause по сравнению с WithCancel?
3. Как безопасно читать причину отмены?
4. Как изменить worker, чтобы он корректно завершался?
5. Почему важно не блокироваться на `ctx.Done()`, если возможна гонка?

🛠 Решение:

🔸 В Go 1.21 есть `context.WithCancelCause`, который позволяет задавать причину отмены.
Но `context.Cause(ctx)` вернёт `nil`, **если ты используешь `context.WithCancel`**, либо, если `ctx.Done()` не был срабатывающим.

🔸 В этом коде `worker(ctx)` запускается и сразу блокируется на:

<-ctx.Done()


Но если отмена происходит **до** того, как `worker` успел начать слушать `ctx.Done()`, и ты используешь старую `WithCancel`, `context.Cause` вернёт `nil`.

🔸 **Правильный способ:**

Убедись, что `context.WithCancelCause` действительно используется и `ctx.Done()` слушается вовремя.

Для Go 1.21+ пример рабочий:


func worker(ctx context.Context) {
for {
select {
case <-ctx.Done():
fmt.Println("Worker stopped:", context.Cause(ctx))
return
case <-time.After(100 * time.Millisecond):
fmt.Println("Working...")
}
}
}


🔸 Альтернатива для старых версий Go (<1.21):


ctx, cancel := context.WithCancel(context.Background())
...
fmt.Println("Worker stopped:", ctx.Err()) // вместо Cause


📌 Вывод:
Начиная с Go 1.21, `context.WithCancelCause` даёт более точный контроль за причинами отмены. Но горутины всё равно должны явно проверять `ctx.Done()` через `select`, иначе отмена может пройти незаметно.

🐿️ Задача на логику для собеседования back-end разработчика на GO

— Мы знаем, что в десятичной системе самое большое число из одной цифры - это 9, а из двух - 99. В бинарной системе самое большое число из двух цифр это 11 (3) самое большое число из трех цифр это 111 (7) и самое большое число из 4 цифр это 1111 (15).
Вопрос: каково самое большое число из 8 цифр?

— Подсказка:

1️⃣ 101 - 1 = 9, a 102 - 1 = 99 (Решение через знание степеней 2)
2️⃣ 11110 это 15 * 2 = 30, а 111100 это 15 * 2 * 2 = 60 (Решение через битовый сдвиг)

Ответ:
255

@golang_interview

🐹 Go-задача (Go 1.22+): почему вывод вас удивит?

package main

import "fmt"

func main() {
    words := []string{"go", "rust", "zig"}
    ptrs  := []*string{}

    for i, v := range words {
        if i == 1 {
            words = append(words, "odin") // добавляем элемент во время range
        }
        ptrs = append(ptrs, &v)          // сохраняем адрес переменной v
    }

    for _, p := range ptrs {
        fmt.Println(*p)
    }
}

❓ Что напечатает программа?

• a) go rust zig
• b) go rust zig odin
• c) zig zig zig zig
• d) go rust zig odin, затем паника

ML-инженеры, какая встреча!

19 июля в Москве снова пройдет Turbo ML Conf от группы Т-Технологий. В этом году — еще масштабнее!

В программе 5 тематических потоков, продовые кейсы и технологии.

Среди спикеров — эксперты Т-Банка, Сбера, Яндекса и других ведущих специалистов.

Будет много нетворкинга, прикладные доклады, настольные игры, лимитированный мерч. Участие бесплатное.

Успейте оставить заявку