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

📜 Условие:

Дана строка 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, затем паника

💡 Go-хак дня:
Ключевое слово type в Go — это мощный инструмент, а не просто способ объявить struct.

Вот что с ним можно:
🔹 Создавать собственные типы на основе int, string, map и т.д.
🔹 Давать удобные псевдонимы стандартным типам
🔹 Прикреплять методы к любому типу — даже к обычному int

Это позволяет писать чистый, читаемый и расширяемый код.
Управляй логикой через свои типы — и код начнёт работать на тебя 💪

#GoLang #GoTips #LearnGo

@golangtests

🧠 Quiz для Go-разработчиков: скомпилируется ли этот код?

type T int
var n T = 1

func foo() {
  switch 1 {
  case n:
  }
}

func bar() {
  switch n {
  case 1:
  }
}

Вопрос: оба switch скомпилируются?
Подумай, а потом напиши ответ в комментариях (Версия go 1.18) 👇

@golangtests

💡 Вместо отправки сигнала в канал, подумай о close() или sync.WaitGroup для завершения горутины.

Оба варианта:

✅ Работают, даже если никто не читает из канала
✅ Позволяют нескольким горутинам реагировать на завершение

Такой подход делает код чище и избегает утечек.

#golang #concurrency

Уже освоили базу Go, но хотите выйти на новый уровень и научиться работать с памятью напрямую?

📍 На открытом уроке «Пакет unsafe. Godmode ON» 23 июля в 20:00 МСК мы покажем как небезопасные операции с памятью расширяют возможности Go-разработчика: от обхода ограничений type safety до повышения производительности.

Представьте: вы разбираетесь, как устроена память внутри Go-объектов, вручную управляете указателями и получаете контроль над структурой данных. Вместе с экспертом вы протестируете кейсы, поймёте риски и преимущества.

👉 Регистрируйтесь и получите скидку на участие в большом курсе «Golang Developer. Professional»: https://otus.pw/OuX6/

Реклама. ООО "ОТУС ОНЛАЙН-ОБРАЗОВАНИЕ", ИНН: 9705100963

✅ В Go можно запускать тесты без единой внешней библиотеки — всё встроено из коробки!
Вот как протестировать код в 3 шага:

1️⃣ Создай файл с суффиксом _test.go — например, sum_test.go
2️⃣ Импортируй пакет testing и напиши функцию вида: TestXxx(t *testing.T)
3️⃣ Запусти тесты командой: go test

Никаких зависимостей. Никаких настроек. Просто пиши код и проверяй его сразу.

#golang #testing #unittest

Я сам решу! Что нужно идти на Golang meetup by Sber — 6 августа в 18:00! 😉

В программе 3 доклада:

🔹 «Улучшаем качество отчётов нагрузочного тестирования с помощью Go, langchain и GigaChat». Антон Юрченко, Сбер

🔹 «Не ждите ковариантности в Go — берите дженерики в работу». Станислав Иванкевич, СберТех

🔹 «Покой и любовь в тестировании сервисов на Go». Макс Теричев, YADRO

А ещё — стенды, нетворкинг и фуршет ☺️

Участвуйте как удобно: офлайн в Москве или онлайн. Ждём вас — регистрируйтесь по ссылке! 👌