задачки со скриннинга(что помню)

package main

import (
	"fmt"
	"time"
)

func first() {
	a := make([]int, 0) // [] len 0 cap 0
	a = append(a, 1)    // [1] len 1 cap 1
	a = append(a, 2)    //[1, 2] len 2 cap 2
	a = append(a, 3)    //[1, 2, 3] len 3 cap 4
	b := append(a, 4)   // a: [1, 2, 3] l3 c4    b:[1,2,3,4] l4 c4
	c := append(a, 5)
	//a: [1, 2, 3] l3 c4
	//b: [1, 2, 3, 5] l4 c4
	//c: [1, 2, 3, 5] l4 c4(ссылается на массив b, так как капа не поменялась)

	c[3] = 1
	// Что в a, b,c по шагам спрашивали
	fmt.Println(a, b, c)
}

func second() {
	start := time.Now()
	_, _ = await(), await()
	// Сколько пройдет времени?
	fmt.Println(time.Since(start))
}

func await() int {
	time.Sleep(3 * time.Second)
	return 1
}

func third() {
	// Тут какие значения I в замыкании
	i := 0
	for i < 10 {
		go func(i int) {
			fmt.Println(i)
		}(i)
		i++
	}

	var counter int
	for i := 0; i < 1000; i++ {
		go func() {
			counter++
		}()
	}
	fmt.Println(counter)
}
func third_fix() {
	for i := 0; i < 10; i++ {
		go func(i int) {
			fmt.Println(i)
		}(i)
	}

}

func fourth() {
	a := []string{"a", "b", "c"}
	for _, v := range a {
		go func() {
			fmt.Println(v)
		}()
	}
	// что выведет?
}

func five_datarace() int {
	var i int
	go func() {
		i = 5
	}()
	// че вернет?

	return i
}

func map_test() {
	a := make(map[int]bool)
	a[0] = true
	a[1] = true

	fmt.Println(a[0], a[1], a[2], a[3], a[4], a[5])
	// что выведет?
}

func slice_test() {
	// вопрос такой: что будет в финале в arr, slice, slice_t?
	arr := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

	slice := arr[0:5]
	slice_t := arr[0:1]

	fmt.Println("Slice:")
	fmt.Println(slice, len(slice), cap(slice))

	fmt.Println("Slice_t:")
	fmt.Println(slice_t, len(slice_t), cap(slice_t))

	slice_t = append(slice_t, 10)
	slice_t = append(slice_t, 11)
	slice_t = append(slice_t, 12)
	slice_t = append(slice_t, 13)
	slice_t = append(slice_t, 14) //тут происходит хитрая штука
	slice_t = append(slice_t, 15)

	fmt.Printf("Slice: %v \nSlice_t: %v\n\n", slice, slice_t)

	fmt.Println("Slice:", slice, len(slice), cap(slice))

	fmt.Println("Slice_t:", slice_t, len(slice_t), cap(slice_t))

	arr[0] = -1
	fmt.Println("Arr:", arr, len(arr), cap(arr))
}

func slice_test1() {
	// slice := make([]int, 0)
	// fmt.Println(slice, len(slice), cap(slice))
	// slice = append(slice, 1)
	// fmt.Println(slice, len(slice), cap(slice))

	s := make([]byte, 3, 6)
	s[0] = 'a'
	s[1] = 'b'
	s[2] = 'c'

	t := s                       //копия s, лен 3 кап 6 ссылка на тот же массив
	s = append(s, 'd', 'e', 'f') // у с длина выросла, капа осталась той же, у t под копотом тот же массив но длина 3

	s = append(s, 'g')

	fmt.Println(s, len(s), cap(s))
	fmt.Println(t, len(t), cap(t))
}

func slice_test2() bool {
	a := make([]bool, 0)
	b := make([]bool, 0)
	a[0] = true
	b[0] = true
	// return a == b
	return false

}

// Горутины:
/*
GMP - горутины, маниша(потоки ОС), процессор(планировщик)
горутина весит 2кб, может расти до 1гб(64)или 250мб(32) или уменьшаться. Стандартный поток в ОС весит 2мб.
P распределяет G по потокам ОС(M). Изначально потоков GOMAXPROC столько же сколько ядер в ОС.
Стек хранит два указателя - начало и конец памяти
M - машинный тред
П - Какая горутина исполняется
Г - горутина
создается число М, испольняется горутина, есть локальная

*/