> For the complete documentation index, see [llms.txt](https://yuliyas-organization-3.gitbook.io/prokhodim-sobesedovanie-na-golang-razrabotchika/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://yuliyas-organization-3.gitbook.io/prokhodim-sobesedovanie-na-golang-razrabotchika/golang-zadachi/nerassortirovannye-zadachi.md).
# Нерассортированные задачи
\========================
\=== Слайсы, Мапы ===
\========================
++++++++++
Задача 1
++++++++++
Что выведет код?
func main() {
v := \[]int{3, 4, 1, 2, 5}
ap(v)
sr(v)
fmt.Println(v)
}
func ap(arr \[]int) {
arr = append(arr, 10)
}
func sr(arr \[]int) {
sort.Ints(arr)
}
\
++++++++++
Задача 2
++++++++++
1\. Что выведет код?
\
var foo \[]int
var bar \[]int
foo = append(foo, 1)
foo = append(foo, 2)
foo = append(foo, 3)
bar = append(foo, 4)
foo = append(foo, 5)
fmt.Println(foo, bar)
\
++++++++++
Задача 3
++++++++++
1\. Что выведется?
package main
import "fmt"
func main() {
c := \[]string{"A", "B", "D", "E"}
b := c\[1:2]
b = append(b, "TT")
fmt.Println(c)
fmt.Println(b)
}
++++++++++
Задача 4
++++++++++
1\. Что выведет код?
func main() {
var m map\[string]int
for \_, word := range \[]string{"hello", "world", "from", "the",
"best", "language", "in", "the", "world"} {
m\[word]++
}
for k, v := range m {
fmt.Println(k, v)
}
}
++++++++++
Задача 5
++++++++++
1\. Что будет в результате выполнения?
mutate := func(a \[]int) {
a\[0] = 0
a = append(a, 1)
fmt.Println(a)
}
a := \[]int{1, 2, 3, 4}
mutate(a)
fmt.Println(a)
++++++++++
Задача 6
++++++++++
1\. Что выведется?
2\. Зная обо всех таких нюансах, которые могут возникнуть, какие есть рекомендации?
\# Вариант 1
\-----------
func mod(a \[]int) {
for i := range a {
a\[i] = 5
}
fmt.Println(a)
}
func main() {
sl := \[]int{1, 2, 3, 5}
mod(sl)
fmt.Println(sl)
}
\# Вариант 2
\-----------
func mod(a \[]int) {
for i := range a {
a\[i] = 5
}
fmt.Println(a)
}
func main() {
sl := make(\[]int, 4, 8)
sl\[0] = 1
sl\[1] = 2
sl\[2] = 3
sl\[3] = 5
mod(sl)
fmt.Println(sl)
}
\# Вариант 3
\-----------
func mod(a \[]int) {
a = append(a, 125)
for i := range a {
a\[i] = 5
}
fmt.Println(a)
}
func main() {
sl := make(\[]int, 4, 8)
sl\[0] = 1
sl\[1] = 2
sl\[2] = 3
sl\[3] = 5
mod(sl)
fmt.Println(sl)
}
\# Вариант 4
\-----------
func mod(a \[]int) {
a = append(a, 125)
for i := range a {
a\[i] = 5
}
fmt.Println(a)
}
func main() {
sl := \[]int{1, 2, 3, 4, 5}
mod(sl)
fmt.Println(sl)
}
++++++++++
Задача 7
++++++++++
1\. Что будет содержать s после инициализации?
2\. Что произойдет в println для слайса и для мапы?
func a(s \[]int) {
s = append(s, 37)
}
func b(m map\[int]int) {
m\[3] = 33
}
func main() {
s := make(\[]int, 3, 8)
m := make(map\[int]int, 8)
// add to slice
a(s)
println(s\[3]) //?
// add to map
b(m)
println(m\[3]) //?
}
++++++++++
Задача 8
++++++++++
1\. Расскажи подробно что происходит
\# Вариант 1
\-----------
package main
import "fmt"
func main() {
a := \[]int{1,2}
a = append(a, 3)
b := append(a, 4)
c := append(a, 5)
fmt.Println(b)
fmt.Println(c)
}
\# Вариант 2
\-----------
package main
import "fmt"
func main() {
a := \[]int{1,2}
a = append(a, 3)
a = append(a, 7)
b := append(a, 4)
c := append(a, 5)
fmt.Println(b)
fmt.Println(c)
}
\
\============================
\==== Многопоточка ====
\============================
++++++++++
Задача 1
++++++++++
Что выведет код? Исправить все проблемы
func main() {
ch := make(chan int)
wg := \&sync.WaitGroup{}
wg.Add(3)
for i := 0; i < 3; i++ {
go func(v int) {
defer wg.Done()
ch <- v \* v
}(i)
}
wg.Wait()
var sum int
for v := range ch {
sum += v
}
fmt.Printf("result: %d\n", sum)
}
\
++++++++++
Задача 2
++++++++++
Что выведет код? Должны выводится все значения
func main() {
a := 5000
for i := 0; i < a; i++ {
go fmt.Println(i)
}
}
\
++++++++++
Задача 3
++++++++++
Будет ошибка что все горутины заблокированы. Какие горутины будут заблокированы? И почему?
package main
import "fmt"
func main() {
ch := make(chan int)
ch <- 1
go func() {
fmt.Println(<-ch)
}()
}
++++++++++
Задача 4
++++++++++
1\. Как это работает, что не так, что поправить?
func main() {
ch := make(chan bool)
ch <- true
go func() {
<-ch
}()
ch <-true
}
++++++++++
Задача 5
++++++++++
1\. Как будет работать код?
2\. Как сделать так, чтобы выводился только первый ch?
func main() {
ch := make(chan bool)
ch2 := make(chan bool)
ch3 := make(chan bool)
go func() {
ch <- true
}()
go func() {
ch2 <- true
}()
go func() {
ch3 <- true
}()
select {
case <-ch:
fmt.Printf("val from ch")
case <-ch2:
fmt.Printf("val from ch2")
case <-ch3:
fmt.Printf("val from ch3")
}
}
++++++++++
Задача 6
++++++++++
1\. Что выведет код и как исправить?
var globalMap = map\[string]\[]int{"test": make(\[]int, 0), "test2": make(\[]int, 0), "test3": make(\[]int, 0)}
var a = 0
func main() {
wg := sync.WaitGroup{}
wg.Add(3)
go func() {
wg.Done()
a=10
globalMap\["test"] = append(globalMap\["test"], a)
}()
go func() {
wg.Done()
a=11
globalMap\["test2"] = append(globalMap\["test2"], a)
}()
go func() {
wg.Done()
a=12
globalMap\["test3"] = append(globalMap\["test3"], a)
}()
wg.Wait()
fmt.Printf("%v", globalMap)
fmt.Printf("%d", a)
}
++++++++++
Задача 7
++++++++++
type Result struct{}
type SearchFunc func(ctx context.Context, query string) (Result, error)
func MultiSearch(ctx context.Context, query string, sfs \[]SearchFunc) (Result, error) {
// Нужно реализовать функцию, которая выполняет поиск query во всех переданных SearchFunc
// Когда получаем первый успешный результат - отдаем его сразу. Если все SearchFunc отработали
// с ошибкой - отдаем последнюю полученную ошибку
}
++++++++++
Задача 8
++++++++++
1\. Что выведется и как исправить?
func main() {
var counter int
for i := 0; i < 1000; i++ {
go func() {
counter++
}()
}
fmt.Println(counter)
}
++++++++++
Задача 9
++++++++++
1\. Что выведется и как исправить?
2\. Что поправить, чтобы сохранить порядок?
func main() {
m := make(char string, 3)
cnt := 5
for i := 0; i < cnt; i++ {
go func() {
m <- fmt.Sprintf("Goroutine %d", i)
}()
}
for i := 0; i < cnt; i++ {
go ReceiveFromCh(m)
}
}
func ReceiveFromCh(ch chan string) {
fmt.Println(<-ch)
}
+++++++++++
Задача 10
+++++++++++
1\. Merge n channels
2\. Если один из входных каналов закрывается, то нужно закрыть все остальные каналы
func case3(channels ...chan int) chan int {
}
+++++++++++
Задача 11
+++++++++++
1\. Описать словами. Предположим есть метод REST API. В нем мы хотим сделать 10 запросов к другим API. Нужно считать данные и отправить пользователю. Как это сделать? Как добавить таймаут? Стоит ли использовать каналы или можно WaitGroup?
+++++++++++
Задача 12
+++++++++++
1\. Конурентно по батчам запросить данные и записать в файл. Нужна общая конструкция, функции которые делают запрос к сайту и выгрузку в файл можно не реализовывать.
2\. Сделать так, чтобы одновременно выполнялось не более chunkSize запросов.
package main
const url = \`
const chunkSize = 100
const dataCount = 2 << 10
+++++++++++
Задача 13
+++++++++++
1\. Запросить параллельно данные из источников. Если все где-то произошла ошибка, то вернуть ошибку, иначе вернуть nil.
2\. Представим, что теперь функция должна возвращать результат int. Есть функция resp.Size(), для каждого url надо проссумировать и вернуть, если ошибок не было. Просто описать подход к решению
3\. Что делать, если урлов у нас миллионы?
package main
func main() {
\_, err := download(\[]string{
"",
"",
"",
"",
"",
})
if err != nil {
panic(err)
}
}
func download(urls \[]string) (error) {
return nil
}
\
+++++++++++
Задача 14
+++++++++++
1\. Что выведет на экран и сколько времени будет работать?
2\. Нужно ускорить, чтобы работало быстрее. Сколько будет работать теперь?
3\. Если бы в networkRequest выполнялся реальный сетевой вызов, то какие с какими проблемами мы могли бы столкнуться в данном коде?
4\. Если url немного, а запросов к ним много, то как можно оптимизировать?
package main
import (
"fmt"
"time"
)
const numRequests = 10000
var count int
var m sync.Mutex
func networkRequest() {
time.Sleep(time.Millisecond) // Эмуляция сетевого запроса.
m.Lock()
count++
m.Unlock()
}
func main() {
var wg sync.WaitGroup
wg.Add(numRequests)
for i := 0; i < numRequests; i++ {
go func() {
defer wg.Done()
networkRequest()
}()
}
wg.Wait()
fmt.Println(count)
}
+++++++++++
Задача 15
+++++++++++
// Есть функция unpredictableFunc, работающая неопределенно долго и возвращающая число.
// Её тело нельзя изменять (представим, что внутри сетевой запрос).
// Нужно написать обертку predictableFunc,
// которая будет работать с заданным фиксированным таймаутом (например, 1 секунду).
package main
import (
"fmt"
"math/rand"
"time"
)
func init() {
rand.Seed(time.Now().UnixNano())
}
// Есть функция, работающая неопределенно долго и возвращающая число.
// Её тело нельзя изменять (представим, что внутри сетевой запрос).
func unpredictableFunc() int64 {
rnd := rand.Int63n(5000)
time.Sleep(time.Duration(rnd) \* time.Millisecond)
return rnd
}
// Нужно изменить функцию обертку, которая будет работать с заданным таймаутом (например, 1 секунду).
// Если "длинная" функция отработала за это время - отлично, возвращаем результат.
// Если нет - возвращаем ошибку. Результат работы в этом случае нам не важен.
//
// Дополнительно нужно измерить, сколько выполнялась эта функция (просто вывести в лог).
// Сигнатуру функцию обёртки менять можно.
func predictableFunc() int64 {
}
func main() {
fmt.Println("started")
fmt.Println(predictableFunc())
}
+++++++++++
Задача 16
+++++++++++
// Написать код функции, которая делает merge N каналов. Весь входной поток перенаправляется в один канал.
func merge(cs ...<-chan int) <-chan int {
}
+++++++++++
Задача 17
+++++++++++
1\. Что выведется? Исправь проблему
\# Вариант1
\----------
x := make(map\[int]int, 1)
go func() { x\[1] = 2 }()
go func() { x\[1] = 7 }()
go func() { x\[1] = 10 }()
time.Sleep(100 \* time.Millisecond)
fmt.Println("x\[1] =", x\[1])
+++++++++++
Задача 18
+++++++++++
1\. Иногда приходят нули. В чем проблема? Исправь ее
2\. Если функция bank\_network\_call выполняется 5 секунд, то за сколько выполнится balance()? Как исправить проблему?
3\. Представим, что bank\_network\_call возвращает ошибку дополнительно. Если хотя бы один вызов завершился с ошибкой, то balance должен вернуть ошибку.
func balance() int {
x := make(map\[int]int, 1)
var m sync.Mutex
// call bank
for i := 0; i < 5; i++ {
i := i
go func() {
m.Lock()
b := bank\_network\_call(i)
x\[i] = b
m.Unlock()
}()
}
// Как-то считается сумма значений в мапе и возвращается
return sumOfMap
}
\
\
\==========================
\==== Интерфейсы ====
\==========================
++++++++++
Задача 1
++++++++++
Что выведет код?
type impl struct{}
type I interface {
C()
}
func (\*impl) C() {}
func A() I {
return nil
}
func B() I {
var ret \*impl
return ret
}
func main() {
a := A()
b := B()
fmt.Println(a == b)
}
++++++++++
Задача 2
++++++++++
1\. Добавить код, который выведет тип переменной whoami
func printType(whoami interface{}) {
}
func main() {
printType(42)
printType("im string")
printType(true)
}
++++++++++
Задача 3
++++++++++
Исправить функцию, чтобы она работала. Сигнатуру менять нельзя
func printNumber(ptrToNumber interface{}) {
if ptrToNumber != nil {
fmt.Println(\*ptrToNumber.(\*int))
} else {
fmt.Println("nil")
}
}
func main() {
v := 10
printNumber(\&v)
var pv \*int
printNumber(pv)
pv = \&v
printNumber(pv)
}
\==========================
\==== Разные темы ====
\==========================
++++++++++
Задача 1
++++++++++
1\. Что выведется?
package main
import (
"fmt"
"math"
)
func main() {
x := 2.0
y := 3.0
result := math.Pow(x, y)
fmt.Println("%f ^ %f = %f\n", x, y, result)
}
++++++++++
Задача 2
++++++++++
1\. Что выведет код?
func main() {
fmt.Println("start")
for i := 1; i < 4; i++ {
defer fmt.Println(i)
}
fmt.Println("end")
}
++++++++++
Задача 3
++++++++++
1\. Что будет в результате выполнения теста?
type User struct {
Valid bool
Id int64
Number int32
}
type CUser struct {
Id int64
Number int32
Valid bool
}
func TestSize(t \*testing.T) {
user := User{}
cuser := CUser{}
if unsafe.Sizeof(user) == unsafe.Sizeof(cuser) {
t.Log("structs size are equal")
}
}
++++++++++
Задача 4
++++++++++
1\. Какие строки работают нормально, а какие нет и почему?
package main
type T \[]int
func (T) X(){}
func (\*T) Z(){}
func main() {
var t T
t.X() // 1
t.Z() // 2
var p = \&t
p.X() // 3
p.Z() // 4
T{}.X() // 5
T{}.Z() // 6
}
++++++++++
Задача 5
++++++++++
1\. Расскажи подробно что происходит
2\. Как сделать так, чтобы работало?
package main
import "fmt"
func main() {
str := "Привет"
str\[2] = 'e'
fmt.Println(str)
}
\
\==========================
\==== Кастомные ====
\==========================
++++++++++
Задача 1
++++++++++
1\. Написать функцию, которая принимает число N и возвращает слайс размера N с уникальными числами.
2\. Идеи как тестировать функцию?
\
++++++++++
Задача 2
++++++++++
1\. Нужно написать функцию генератор паролей, которая принимает целое число n, а на выходе строка длины n из букв a-zA-Z и 0-9
2\. Что тут можно улучшить?
3\. Какие тесты ты бы написал для нее? Есть какая-нибудь возможность угадать, какая строка будет генерироваться, чтобы писать тесты?
++++++++++
Задача 3
++++++++++
Написать функцию, которая устанавливает i-ый бит числа в 0
\
++++++++++
Задача 4
++++++++++
package main
type Data struct {
ID int
Payload map\[string]interface{}
}
type Reader interface{
Read() \[]\*Data
}
type Processor interface{
Process(Data) (\[]\*Data, error)
}
type Writer interface{
Write(\[]\*Data)
}
type Manager interface{
Manage() // blocking
}
// Необходимо имплементировать интерфейс Manager так, чтобы Manager мог принимать данные из одного Reader
// обрабатывать полученные данные на каждом из списка Processor и результирующие данные передавать в Writer.
// При возникновении ошибки при обработке, прочитанные из Reader данные необходимо пропустить.
++++++++++
Задача 5
++++++++++
1\. Релизовать ручку так, чтобы она выполнялась быстрее чем за одну секунду
2\. Теперь допустим, что запрашивается температура в каком-то location\_id. Опиши, как это реализовать.
// Есть функция getWeather, которая через нейронную сеть вычисляет температуру за \~1 секунду
// Есть highload ручка /weather/highload с нагрузкой 3k RPS
// Необходимо реализовать код этой ручки
func getWeather() int {
time.Sleep(1 \* time.Second)
return rand.Intn(70) - 30
}
func main() {
http.HandleFunc("/weather/highload", func(resp http.ResponseWriter, req \*http.Request) {
\
})
}
++++++++++
Задача 6
++++++++++
1\. Реализовать кеш. Для простоты считаем, что у нас бесконечная память и нам не нужно задумываться об удалении ключей из него.
1\. Почему использовал RWMutex, а не Mutex?
2\. Теперь представим что память не бесконечная. С какими проблемами столкнемся и как их решить?
1\. Какие есть алгоритмы выселения?
3\. Реализуй LRU
// In-memory cache
// Нужно написать простую библиотеку in-memory cache.
// Реализация должна удовлетворять интерфейсу:
type Cache interface {
Set(k, v string)
Get(k string) (v string, ok bool)
}
\
\=====================
\==== Ревью ====
\=====================
++++++++++
Задача 1
++++++++++
Ревью кода (github.com/nosuchpersonn/interview\_project)
\
++++++++++
Задача 2
++++++++++
Ревью кода (github.com/nosuchpersonn/some\_app)
\
++++++++++
Задача 3
++++++++++
Ревью кода (github.com/nosuchpersonn/some\_app\_2)