отредактировано 2 главы

part_1/1.10/1.10.1/1.go

@@ -0,0 +1,14 @@
+package main
+
+import "fmt"
+
+func main() {
+	t := 20
+	if t >= 30 {
+		fmt.Println("Надеть шорты")
+	} else {
+		fmt.Println("Надеть брюки")
+	}
+}
+
+// Надеть брюки

part_1/1.10/1.10.1/2.go

@@ -0,0 +1,13 @@
+package main
+
+import "fmt"
+
+func main() {
+	sun := true // поменяйте на false и снова запустите приложение
+	if !sun {
+		fmt.Println("Взять зонт")
+	}
+	fmt.Println("Выйти на улицу")
+}
+
+// Выйти на улицу

part_1/1.10/1.10.1/3.go

@@ -0,0 +1,18 @@
+package main
+
+import "fmt"
+
+func main() {
+	var value int = 15
+	if value > 0 && value < 10 {
+		fmt.Println("Число входит в диапазон от 0 до 10")
+	} else if value > 10 && value < 20 {
+		fmt.Println("Число входит в диапазон от 10 до 20")
+	} else if value > 20 && value < 30 {
+		fmt.Println("Число входит в диапазон от 20 до 30")
+	} else {
+		fmt.Println("Значение > 30")
+	}
+}
+
+// Число входит в диапазон от 10 до 20

part_1/1.10/1.10.1/4.go

@@ -0,0 +1,22 @@
+package main
+
+import "fmt"
+
+func main() {
+	var value int = 15
+	if value > 30 {
+		if value < 50 {
+			fmt.Println("30 < value < 50")
+		} else {
+			fmt.Println("30 < value >= 50")
+		}
+	} else {
+		if value > 10 {
+			fmt.Println("30 >= value >= 10")
+		} else {
+			fmt.Println("30 >= value < 10")
+		}
+	}
+}
+
+// 30 >= value >= 10

part_1/1.10/1.10.1/5.go

@@ -0,0 +1,13 @@
+package main
+
+import "fmt"
+
+func main() {
+	if value := 15; value > 30 {
+		fmt.Println("30 < value")
+	} else {
+		fmt.Println("30 >= value")
+	}
+}
+
+// 30 >= value

part_1/1.10/1.10.2/1.go

@@ -0,0 +1,19 @@
+package main
+
+import "fmt"
+
+func main() {
+	value := 2
+	switch value {
+	case 2:
+		fmt.Println("2")
+		fmt.Printf("%d + 2 = %d", value, value+2)
+	case 4:
+		fmt.Println("4")
+	default:
+		fmt.Println("8")
+	}
+}
+
+// 2
+// 2 + 2 = 4

part_1/1.10/1.10.2/2.go

@@ -0,0 +1,20 @@
+package main
+
+import "fmt"
+
+func main() {
+	value := 2
+	switch value := 4; value {
+	case 2:
+		fmt.Println("2")
+		fmt.Printf("%d + 2 = %d", value, value+2)
+	case 4:
+		fmt.Println("4")
+	default:
+		fmt.Println("8")
+	}
+	fmt.Printf("value = %d", value)
+}
+
+// 4
+// value = 2

part_1/1.10/1.10.2/3.go

@@ -0,0 +1,15 @@
+package main
+
+import "fmt"
+
+func main() {
+	name := "Alex"
+	switch name {
+	case "Stanislav":
+		fmt.Println("Admin")
+	case "Maxim", "Alex", "Bill":
+		fmt.Println("Employee")
+	}
+}
+
+// Employee

part_1/1.10/1.10.2/4.go

@@ -0,0 +1,17 @@
+package main
+
+import "fmt"
+
+func main() {
+	name := "Stanislav"
+	switch name {
+	case "Stanislav":
+		fmt.Println("Admin")
+		fallthrough
+	case "Maxim", "Alex", "Bill":
+		fmt.Println("Employee")
+	}
+}
+
+// Admin
+// Employee

part_1/1.10/1.10.2/5.go

@@ -0,0 +1,17 @@
+package main
+
+import "fmt"
+
+func main() {
+	name := "Stanislav"
+	switch name {
+	case "Stanislav":
+		fmt.Println("Admin")
+		break
+		fallthrough
+	case "Maxim", "Alex", "Bill":
+		fmt.Println("Employee")
+	}
+}
+
+// Admin

part_1/1.10/1.10.2/6.go

@@ -0,0 +1,25 @@
+package main
+
+import "fmt"
+
+func main() {
+	var value int = 5
+	switch {
+	case value > 30:
+		switch {
+		case value < 50:
+			fmt.Println("30 < value < 50")
+		default:
+			fmt.Println("30 < value >= 50")
+		}
+	case value < 30:
+		switch {
+		case value > 10:
+			fmt.Println("30 >= value >= 10")
+		default:
+			fmt.Println("30 >= value < 10")
+		}
+	}
+}
+
+// 30 >= value < 10

part_1/1.11/1.go

@@ -0,0 +1,10 @@
+package main
+
+import "fmt"
+
+func main() {
+	value := 2
+	for i := 0; i < 10; i++ {
+		fmt.Printf("%d * %d = %d\n", value, i, value*i)
+	}
+}

part_1/1.11/10.go

@@ -0,0 +1,11 @@
+package main
+
+import "fmt"
+
+func main() {
+	s := "Hello"
+
+	for i := 0; i < len(s); i++ {
+		fmt.Printf("Byte index: %d, Symbol: %c\n", i, s[i])
+	}
+}

part_1/1.11/11.go

@@ -0,0 +1,24 @@
+package main
+
+import "fmt"
+
+func main() {
+
+	for i := 0; i < 5; i++ {
+		fmt.Printf("%d ", i)
+	}
+	fmt.Println()
+
+	// или
+	for i := range 5 {
+		fmt.Printf("%d ", i)
+	}
+	fmt.Println()
+
+	// или
+	i := 0
+	for range 5 {
+		fmt.Printf("%d ", i)
+		i++
+	}
+}

part_1/1.11/2.go

@@ -0,0 +1,19 @@
+package main
+
+import (
+	"fmt"
+	"strconv"
+)
+
+func main() {
+	str := ""
+	i := 0
+	for {
+		str += strconv.Itoa(i)
+		if i >= 5 {
+			break
+		}
+		i++
+	}
+	fmt.Println(str) // 012345
+}

part_1/1.11/3.go

@@ -0,0 +1,16 @@
+package main
+
+import (
+	"fmt"
+	"strconv"
+)
+
+func main() {
+	str := ""
+	i := 0
+	for i <= 5 {
+		str += strconv.Itoa(i)
+		i++
+	}
+	fmt.Println(str) // 012345
+}

part_1/1.11/4.go

@@ -0,0 +1,14 @@
+package main
+
+import "fmt"
+
+func main() {
+	i := 13
+	for i > 0 {
+		i--
+		if i%2 == 0 {
+			continue
+		}
+		fmt.Printf("%d ", i)
+	}
+}

part_1/1.11/5.go

@@ -0,0 +1,27 @@
+package main
+
+import "fmt"
+
+func main() {
+	for i := 0; i < 2; i++ {
+		for j := 0; j < 3; j++ {
+			if i == j {
+				continue
+			}
+			fmt.Printf("%d %d || ", i, j)
+		}
+	}
+	// 0 1 || 0 2 || 1 0 || 1 2 ||
+
+	fmt.Println()
+	for i := 0; i < 2; i++ {
+		for j := 0; j < 3; j++ {
+			if i == j {
+				break
+			}
+			fmt.Printf("%d %d || ", i, j)
+		}
+	}
+	fmt.Println("Oo")
+	// 1 0 || Oo
+}

part_1/1.11/6.go

@@ -0,0 +1,11 @@
+package main
+
+import "fmt"
+
+func main() {
+	array := [4]int{2, 5, 6, 0}
+	for i := 0; i < len(array); i++ {
+		array[i] += 3
+		fmt.Printf("%d ", array[i])
+	}
+}

part_1/1.11/7.go

@@ -0,0 +1,22 @@
+package main
+
+import "fmt"
+
+func main() {
+	array := [4]int{2, 5, 6, 0}
+	for i, v := range array {
+		// i - номер индекса элемента
+		// v – копия значения, хранящаяся по индексу i
+		v += 3
+		fmt.Printf("%d) %d || ", i, v)
+	}
+	// 0) 5 || 1) 8 || 2) 9 || 3) 3 ||
+	fmt.Println()
+	fmt.Println(array) // [2 5 6 0]
+
+	// изменение значения элемента коллекции
+	for i := range array {
+		array[i] += 3
+	}
+	fmt.Println(array) // [5 8 9 3]
+}

part_1/1.11/8.go

@@ -0,0 +1,17 @@
+package main
+
+import "fmt"
+
+func main() {
+	myMap := map[int]string{
+		1:   "Alex",
+		2:   "Maxim",
+		200: "Jon",
+	}
+
+	for i, v := range myMap {
+		// i - ключ
+		// v – копия значения, хранящаяся по ключу i
+		fmt.Printf("key = %d, value = %s\n", i, v)
+	}
+}

part_1/1.11/9.go

@@ -0,0 +1,13 @@
+package main
+
+import "fmt"
+
+func main() {
+	s := "Привет"
+
+	for i, r := range s {
+		// i - номер индекса, где располагается первый байт символа
+		// v – копия символа приведенная к типу Rune
+		fmt.Printf("Rune index: %d, Rune: %c (Hex: %x)\n", i, r, r)
+	}
+}

part_1/1.12/1.go

@@ -0,0 +1,11 @@
+package main
+
+import "fmt"
+
+func main() {
+	fmt.Println(1) // 1
+	goto myLable
+	fmt.Println(2)
+myLable: // метка для безусловного перехода
+	fmt.Println(3) // 3
+}

part_1/1.12/2.go

@@ -0,0 +1,16 @@
+package main
+
+import "fmt"
+
+func main() {
+	test()
+	fmt.Println(1)
+	goto myLable
+	fmt.Println(2)
+myLable:
+	fmt.Println(3)
+}
+
+func test() {
+	goto myLable // error: label myLable not defined
+}

part_1/1.12/3.go

@@ -0,0 +1,10 @@
+package main
+
+import "fmt"
+
+func main() {
+myLable: // бесконечный цикл
+	fmt.Println(1)
+	goto myLable
+	fmt.Println(2)
+}

part_1/1.13/1.go

@@ -0,0 +1,13 @@
+package main
+
+import "fmt"
+
+func main() {
+	var val1 int8 = 5
+	var val2 int16 = 500
+	rez1 := int16(val1) + val2
+	// rez2 := val1 + val2
+	// invalid operation: val1 + val2 (mismatched types int8 and int16)
+
+	fmt.Println(rez1) // 505
+}

part_1/1.13/10.go

@@ -0,0 +1,17 @@
+package main
+
+import "fmt"
+
+func main() {
+	myBool := true
+	var value int
+	if myBool {
+		value = 1
+	} else {
+		value = 0
+	}
+	fmt.Println("Value = ", value) // Value =  1
+
+	myBool2 := value == 1
+	fmt.Println("myBool2 value = ", myBool2) // myBool2 value = true
+}

part_1/1.13/2.go

@@ -0,0 +1,11 @@
+package main
+
+import "fmt"
+
+func main() {
+	var val1 int8 = 5
+	var val2 int16 = 500
+	rez1 := val1 + int8(val2)
+	fmt.Println(rez1)       // –7
+	fmt.Println(int8(val2)) // –12
+}

part_1/1.13/3.go

@@ -0,0 +1,12 @@
+package main
+
+import "fmt"
+
+func main() {
+	var val1 int = 5
+	var val2 float32 = 5.32
+	fmt.Printf("%.1f\n", float32(val1)) // 5.0,
+	// Printf рассматривается в следующем разделе
+
+	fmt.Println(int(val2)) // 5
+}

part_1/1.13/4.go

@@ -0,0 +1,11 @@
+package main
+
+import "fmt"
+
+func main() {
+	var val1 uint8 = 5 // от 0 до 255
+	var val2 uint8 = 255
+	fmt.Println(val2 + val1) // 4
+	rez1 := uint16(val1) + uint16(val2)
+	fmt.Println(rez1) // 260
+}

part_1/1.13/5.go

@@ -0,0 +1,9 @@
+package main
+
+import "fmt"
+
+func main() {
+	var val1 uint8 = 255 // 1111 1111 в двоичной системе счисления
+	val2 := int8(val1)
+	fmt.Println(val2) //–1, что =1111 1111 в двоичной системе счисления
+}

part_1/1.13/6.go

@@ -0,0 +1,11 @@
+package main
+
+import "fmt"
+
+func main() {
+	val1 := 4 / 3
+	fmt.Println(val1) // 1
+
+	val2 := 4.0 / 3
+	fmt.Println(val2) // 1.3333333333333333
+}

part_1/1.13/7.go

@@ -0,0 +1,25 @@
+package main
+
+import (
+	"fmt"
+	"reflect"
+	"strconv"
+)
+
+func main() {
+	val1 := 33
+	var str string = strconv.Itoa(val1)
+	fmt.Println(str) // 33
+	val2, err := strconv.Atoi(str)
+	if err == nil { // если получилось преобразовать, то err == nil
+		fmt.Println(val2)                 // 33
+		fmt.Println(reflect.TypeOf(val2)) // int
+	}
+	val2, err = strconv.Atoi("ee")
+	if err != nil {
+		fmt.Println(val2) // 0
+	}
+
+	val3 := 100
+	fmt.Println("Rezult: " + strconv.Itoa(val3)) // Rezult: 100
+}

part_1/1.13/8.go

@@ -0,0 +1,18 @@
+package main
+
+import (
+    "fmt"
+    "reflect"
+    "strconv"
+)
+
+func main() {
+    val1 := 33.321
+    str1 := strconv.FormatFloat(val1, 'f', –1, 64)
+    // равносильно
+    str2 := fmt.Sprintf("%.3f", val1)
+    fmt.Println(reflect.TypeOf(str2) , str2) // string 33.321
+    fmt.Println(reflect.TypeOf(str1), str1) // string 33.321 
+    val2, _ := strconv.ParseFloat(str2, 64)
+    fmt.Println(reflect.TypeOf(val2), val2) // float64 33.321
+}

part_1/1.13/9.go

@@ -0,0 +1,14 @@
+package main
+
+import "fmt"
+
+func main() {
+	str1 := "hello"
+	fmt.Println(str1) // hello
+
+	byteArray := []byte(str1)
+	fmt.Println(byteArray) // [104 101 108 108 111]
+
+	str2 := string(byteArray)
+	fmt.Println(str2) // hello
+}

part_1/1.14/1.go

@@ -0,0 +1,18 @@
+package main
+
+import (
+	"fmt"
+	"os"
+)
+
+func main() {
+	var cityName string
+	var age int
+	fmt.Print("Введите название города, в котором проживаете: ")
+	fmt.Fscan(os.Stdin, &cityName)
+
+	fmt.Print("Введите возраст города: ")
+	fmt.Fscan(os.Stdin, &age)
+
+	fmt.Println(cityName, age)
+}

part_1/1.14/10.go

@@ -0,0 +1,8 @@
+package main
+
+import "fmt"
+
+func main() {
+	fmt.Print(4, 5.13, "Oo")
+	fmt.Print(10) // 4 5.13Oo10
+}

part_1/1.14/11.go

@@ -0,0 +1,8 @@
+package main
+
+import "fmt"
+
+func main() {
+	value := 20
+	fmt.Printf("Value = %v", value) // Value = 20
+}

part_1/1.14/12.go

@@ -0,0 +1,11 @@
+package main
+
+import "fmt"
+
+func main() {
+	value1 := 20
+	var value2 float32 = 4.33
+	value3 := "O"
+	fmt.Printf("Type value1 = %T, value2 = %T, value3 = %T", value1, value2, value3)
+	// Type value1 = int, value2 = float32, value3 = string
+}

part_1/1.14/13.go

@@ -0,0 +1,8 @@
+package main
+
+import "fmt"
+
+func main() {
+	value := 20
+	fmt.Printf("Value1 = %v%%", value) // Value1 = 20%
+}

part_1/1.14/14.go

@@ -0,0 +1,11 @@
+package main
+
+import "fmt"
+
+func main() {
+	value := 173.000473
+	fmt.Printf("Value = %f\n", value)    // Value = 173.000473
+	fmt.Printf("Value = %.f\n", value)   // Value = 173
+	fmt.Printf("Value = %.5f\n", value)  // Value = 173.00047
+	fmt.Printf("Value = %2.2f\n", value) // Value = 173.00
+}

part_1/1.14/15.go

@@ -0,0 +1,9 @@
+package main
+
+import "fmt"
+
+func main() {
+	value := 173.000473
+	str := fmt.Sprintf("Value = %x", value)
+	fmt.Printf("str = %q\n", str)
+}

part_1/1.14/2.go

@@ -0,0 +1,15 @@
+package main
+
+import (
+	"fmt"
+	"os"
+)
+
+func main() {
+	var cityName string
+	var age int
+	fmt.Println("Введите название города, в котором проживаете и его возраст: ")
+	fmt.Fscan(os.Stdin, &cityName, &age)
+
+	fmt.Println(cityName, age)
+}

part_1/1.14/3.go

@@ -0,0 +1,12 @@
+package main
+
+import (
+	"fmt"
+	"os"
+)
+
+func main() {
+	var value1, value2 string
+	fmt.Fscan(os.Stdin, &value1, &value2)
+	fmt.Println(value1, value2)
+}

part_1/1.14/4.go

@@ -0,0 +1,23 @@
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+	"strings"
+)
+
+func main() {
+	// Создаем буфер для чтения из стандартного потока ввода
+	reader := bufio.NewReader(os.Stdin)
+
+	// Считываем первую строку до указанного символа,
+	// где '\n' - символ конца строки + нажатый Enter
+	line1, err := reader.ReadString('\n')
+	if err != nil { // считали строку?
+		return
+	}
+	// Удаляем лишние пробелы
+	line1 = strings.TrimSpace(line1)
+	fmt.Println(line1) // 3 7 8 9 8 7 6 7
+}

part_1/1.14/5.go

@@ -0,0 +1,25 @@
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+	"strings"
+)
+
+func main() {
+	// Создаем буфер для чтения из стандартного потока ввода
+	reader := bufio.NewReader(os.Stdin)
+
+	// Считываем первую строку до указанного символа,
+	// где '\n' - символ конца строки + нажатый Enter
+	for range 2 { // код в теле цикла for будет выполнен 2 раза
+		line1, err := reader.ReadString('|')
+		if err != nil {
+			return
+		}
+		// Удаляем лишние пробелы
+		line1 = strings.TrimSpace(line1)
+		fmt.Println(line1)
+	}
+}

part_1/1.14/6.go

@@ -0,0 +1,21 @@
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+	"strings"
+)
+
+func main() {
+	// Создаем сканер для чтения из стандартного потока ввода
+	scanner := bufio.NewScanner(os.Stdin)
+
+	if scanner.Scan() { // ожидаем ввод данных
+		// если данные прочитаны успешно, выполнится код
+		// тела оператора if
+		input := scanner.Text() // Считываем строку
+		input = strings.TrimSpace(input)
+		fmt.Println(input)
+	}
+}

part_1/1.14/7.go

@@ -0,0 +1,46 @@
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+	"strconv"
+	"strings"
+)
+
+func main() {
+	scanner := bufio.NewScanner(os.Stdin)
+	fmt.Println("Введите целые числа, разделенные пробелами:")
+
+	// Считываем одну строку ввода
+	scanner.Scan()
+	input := scanner.Text()
+
+	// Разбиваем строку на срез строк,
+	// используя в качестве разделителя символ пробела
+	fields := strings.Fields(input)
+
+	var mySlice []int
+	// Преобразуем каждое элемент среза fields в целое число
+	for _, field := range fields {
+		n, err := strconv.Atoi(field)
+		if err != nil {
+			fmt.Println("Ошибка преобразования:", field)
+			return
+		}
+		mySlice = append(mySlice, n)
+	}
+
+	// Удаляем дубликаты
+	var result []int
+	seen := make(map[int]bool)
+	for _, num := range mySlice { // Перебираем элементы среза
+		if !seen[num] { // Если элемент еще не встречался
+			seen[num] = true
+			// Добавляем элемент в результирующий срез
+			result = append(result, num)
+		}
+	}
+
+	fmt.Println("Срез без дубликатов:", result)
+}

part_1/1.14/8.go

@@ -0,0 +1,73 @@
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+	"strconv"
+	"strings"
+)
+
+func main() {
+	scanner := bufio.NewScanner(os.Stdin)
+	var keys []int
+	var values []string
+
+	// Чтение ключей
+	if !scanner.Scan() { // если произошла ошибка
+		return // завершаем выполнение программы
+	}
+	keyParts := strings.Fields(scanner.Text())
+	// преобразование в целочисленный срез
+	for _, part := range keyParts {
+		num, err := strconv.Atoi(part)
+		if err != nil {
+			fmt.Println("Ошибка в ключах:", part)
+			return
+		}
+		keys = append(keys, num)
+	}
+
+	// Чтение значений
+	if !scanner.Scan() {
+		return
+	}
+	values = strings.Fields(scanner.Text())
+
+	// Проверка на то, что количество ключей и значений совпадает
+	if len(keys) != len(values) {
+		fmt.Println("Количество ключей и значений не совпадает")
+		return
+	}
+
+	// Чтение числа A
+	if !scanner.Scan() {
+		return
+	}
+	a, err := strconv.Atoi(scanner.Text())
+	if err != nil || a == 0 {
+		fmt.Println("Некорректное число A")
+		return
+	}
+
+	// Создание и заполнение таблицы
+	data := make(map[int]string)
+	for i := range keys {
+		data[keys[i]] = values[i]
+	}
+
+	// Поиск ключей для удаления
+	var toDelete []int
+	for k := range data {
+		if k%a == 0 {
+			toDelete = append(toDelete, k)
+		}
+	}
+
+	// Удаление элементов
+	for _, k := range toDelete {
+		delete(data, k)
+	}
+
+	fmt.Println(data)
+}

part_1/1.14/9.go

@@ -0,0 +1,8 @@
+package main
+
+import "fmt"
+
+func main() {
+	fmt.Println(4, 5.13, "Oo") // 4 5.13 Oo
+	fmt.Println(10)            // 10
+}

part_1/1.15/1.go

@@ -0,0 +1,31 @@
+package main
+
+import (
+	"fmt"
+	"strings"
+)
+
+func main() {
+	str := " !my string! "
+
+	// удяляем пробелы с обеих сторон
+	fmt.Println(strings.TrimSpace(str)) // !my string!
+
+	// удяляем заданные символы в начале и в конце строки
+	fmt.Println(strings.Trim(str, " "))  // !my string!
+	fmt.Println(strings.Trim(str, " !")) // my string
+
+	// удяляем заданные символы в начале строки
+	fmt.Println(strings.TrimLeft(str, " "))   // !my string!
+	fmt.Println(strings.TrimLeft(str, " m!")) // y string!
+
+	// удяляем заданные символы в конце строки
+	fmt.Println(strings.TrimRight(str, " "))    // !my string!
+	fmt.Println(strings.TrimRight(str, "n!g ")) //  !my stri
+
+	// удяляем заданный символ или подстроку в начале строки
+	fmt.Println(strings.TrimPrefix(str, " !my")) // string!
+
+	// удяляем заданный символ или подстроку в конце строки
+	fmt.Println(strings.TrimSuffix(str, "g! ")) // !my strin
+}

part_1/1.15/10.go

@@ -0,0 +1,13 @@
+package main
+
+import (
+	"fmt"
+	"strings"
+)
+
+func main() {
+	str1 := "Hi, my dear friend!!!"
+	fmt.Printf("%t\n", strings.Contains(str1, "i"))  // true
+	fmt.Printf("%t\n", strings.Contains(str1, "my")) // true
+	fmt.Printf("%t\n", strings.Contains(str1, "?"))  // false
+}

part_1/1.15/11.go

@@ -0,0 +1,33 @@
+package main
+
+import (
+	"fmt"
+	"strings"
+)
+
+func main() {
+	str := "Hello mad world!"
+	before, after, found := strings.Cut(str, " ")
+	fmt.Printf("before: %s, after: %s, found: %t \n", before, after, found)
+	// before: Hello, after: mad world!, found: true
+
+	before, after, found = strings.Cut(str, "6")
+	fmt.Printf("before: %s, after: %s, found: %t \n", before, after, found)
+	// before: Hello mad world!, after: , found: false
+
+	after, found = strings.CutPrefix(str, "He")
+	fmt.Printf("after: %s, found: %t \n", after, found)
+	// after: llo mad world!, found: true
+
+	after, found = strings.CutPrefix(str, "yello")
+	fmt.Printf("after: %s, found: %t \n", after, found)
+	// after: Hello mad world!, found: false
+
+	before, found = strings.CutSuffix(str, "!")
+	fmt.Printf("before: %s, found: %t \n", before, found)
+	// before: Hello mad world, found: true
+
+	before, found = strings.CutSuffix(str, "?")
+	fmt.Printf("before: %s, found: %t \n", before, found)
+	// before: Hello mad world!, found: false
+}

part_1/1.15/12.go

@@ -0,0 +1,13 @@
+package main
+
+import (
+	"fmt"
+	"strings"
+)
+
+func main() {
+	str := "Hello mad world!"
+	fmt.Println(strings.EqualFold(str, "hello mad world!")) // true
+	fmt.Println(strings.EqualFold(str, "HELLO mad world!")) // true
+	fmt.Println(strings.EqualFold(str, "Oo"))               // false
+}

part_1/1.15/13.go

@@ -0,0 +1,16 @@
+package main
+
+import (
+	"fmt"
+	"strings"
+)
+
+func main() {
+	str := "Hello mad world!"
+	fmt.Println(strings.HasPrefix(str, "He"))  // true
+	fmt.Println(strings.HasPrefix(str, "he"))  // false
+	fmt.Println(strings.HasPrefix(str, "mad")) // false
+
+	fmt.Println(strings.HasSuffix(str, "!"))   // true
+	fmt.Println(strings.HasSuffix(str, "mad")) // false
+}

part_1/1.15/14.go

@@ -0,0 +1,15 @@
+package main
+
+import (
+	"fmt"
+	"strings"
+)
+
+func main() {
+	str := "Hello mad world!"
+	fmt.Println(strings.Index(str, "l")) // 2
+	fmt.Println(strings.Index(str, "W")) // -1
+
+	fmt.Println(strings.LastIndex(str, "l")) // 13
+	fmt.Println(strings.LastIndex(str, "W")) // -1
+}

part_1/1.15/15.go

@@ -0,0 +1,21 @@
+package main
+
+import (
+	"fmt"
+	"slices"
+	"strings"
+)
+
+func main() {
+	fmt.Println(strings.Join([]string{"a", "b", "c"}, " "))
+	// a b c
+
+	fmt.Println(strings.Join([]string{"a", "b", "c"}, "-"))
+	// a-b-c
+
+	// инвертирование строки
+	str := "Hello!"
+	splitStr := strings.Split(str, "")
+	slices.Reverse(splitStr)
+	fmt.Println(strings.Join(splitStr, "")) // !olleH
+}

part_1/1.15/16.go

@@ -0,0 +1,43 @@
+package main
+
+import (
+	"fmt"
+	"strings"
+)
+
+func main() {
+	var b strings.Builder
+
+	// Write - записывает байты (строку) в Builder
+	n, err := b.Write([]byte("Hello, "))
+	if err != nil { // проверка на успешное завершение операции
+		panic(err)
+	}
+	fmt.Printf("After Write: %q (bytes written: %d)\n", b.String(), n)
+
+	// WriteString - записывает строку
+	n, _ = b.WriteString("world")
+	fmt.Printf("After WriteString: %q (bytes written: %d)\n", b.String(), n)
+
+	// WriteByte - записывает один байт (символ)
+	b.WriteByte('!')
+	fmt.Printf("After WriteByte: %q\n", b.String())
+
+	// WriteRune - записывает один Unicode-символ
+	n, _ = b.WriteRune('🌍')
+	fmt.Printf("After WriteRune: %q (bytes written: %d)\n", b.String(), n)
+
+	// Len - возвращает текущую длину строки
+	fmt.Printf("Current length: %d\n", b.Len())
+
+	// Cap - возвращает текущую емкость внутреннего буфера
+	fmt.Printf("Current capacity: %d\n", b.Cap())
+
+	// Grow - увеличивает емкость буфера структуры Builder
+	b.Grow(100)
+	fmt.Printf("After Grow(100), new capacity: %d\n", b.Cap())
+
+	// Reset - очищает содержимое буфера Builder-а
+	b.Reset()
+	fmt.Printf("After Reset: %q, length: %d\n", b.String(), b.Len())
+}

part_1/1.15/2.go

@@ -0,0 +1,16 @@
+package main
+
+import (
+	"fmt"
+	"strings"
+)
+
+func main() {
+	str1 := "Hi, my dear friend!!!"
+	str2 := strings.ToUpper(str1)
+	fmt.Println(str2) // HI, MY DEAR FRIEND!!!
+	fmt.Println(str1) // Hi, my dear friend!!!
+
+	fmt.Println(strings.ToLower(str2)) // hi, my dear friend!!!
+	fmt.Println(strings.ToTitle(str1)) // HI, MY DEAR FRIEND!!!
+}

part_1/1.15/3.go

@@ -0,0 +1,9 @@
+package main
+
+import "fmt"
+
+func main() {
+	str1 := "Hi, my dear friend!!!"
+	fmt.Println("Символы с 1 по 5: " + str1[:5])
+	fmt.Println("Символы с 4: " + str1[4:])
+}

part_1/1.15/4.go

@@ -0,0 +1,10 @@
+package main
+
+import "fmt"
+
+func main() {
+	str1 := "Hi, my маленький friend!!!"
+	runes := []rune(str1)
+	substr := string(runes[4:16])
+	fmt.Println(substr) // my маленький
+}

part_1/1.15/5.go

@@ -0,0 +1,39 @@
+package main
+
+import (
+	"fmt"
+	"strings"
+)
+
+func main() {
+	str := "++Hello++ненаглядные++Гофферы!++"
+
+	// Разбиваем строку на срезы по указанному разделителю
+	splitRes := strings.Split(str, "++")
+	fmt.Print("Split(s, \"++\"): ")
+	fmt.Printf("%q\n", splitRes)
+
+	// Разбиваем строку на срезы по указанному разделителю,
+	// сохраняя сам разделитель в конце каждого элемента
+	// (кроме последнего)
+	splitAfterRes := strings.SplitAfter(str, "++")
+	fmt.Print("\nSplitAfter(s, \"++\"): ")
+	fmt.Printf("%q\n", splitAfterRes)
+
+	// Разбиваем строку на срезы по указанному разделителю,
+	// с ограничением на количество подстрок (n). n = 3 означает,
+	// что результат будет содержать не более 3 элементов
+	splitNRes := strings.SplitN(str, "++", 3)
+	fmt.Print("\nSplitN(s, \"++\", 3): ")
+	fmt.Printf("%q\n", splitNRes)
+
+	// при n = 0 результат будет nil - []
+	splitNRes = strings.SplitN(str, "++", 0)
+	fmt.Print("\nSplitN(s, \"++\", 0): ")
+	fmt.Printf("%q\n", splitNRes)
+
+	// при n = -1 результат будет содержать все подстроки
+	splitNRes = strings.SplitN(str, "++", -1)
+	fmt.Print("\nSplitN(s, \"++\", -1): ")
+	fmt.Printf("%q\n", splitNRes)
+}

part_1/1.15/6.go

@@ -0,0 +1,24 @@
+package main
+
+import (
+	"fmt"
+	"strings"
+)
+
+func main() {
+	// Разбиваем строку на срезы по любым пробельным символам:
+	// пробел, табуляция, перенос строки и т.д.
+	str1 := "  Йо   is бедствие  "
+	fieldsRes := strings.Fields(str1)
+	fmt.Print("\nFields(str1): ")
+	fmt.Printf("%q\n", fieldsRes)
+
+	// Разбиваем строку на срезы и задаем
+	// пользовательскую функцию для определения разделителя
+	str2 := "A+B+++C+DE++F"
+	fieldsFuncRes := strings.FieldsFunc(str2, func(r rune) bool {
+		return r == '+' // '+' - разделитель
+	})
+	fmt.Print("\nFieldsFunc(str2, '+'): ")
+	fmt.Printf("%q\n", fieldsFuncRes)
+}

part_1/1.15/7.go

@@ -0,0 +1,24 @@
+package main
+
+import (
+	"fmt"
+	"strings"
+)
+
+func main() {
+	str := "Hi, my dear friend!!!"
+	newStr := strings.Replace(str, "d", "&", 1)
+	fmt.Println(newStr) // Hi, my &ear friend!!!
+
+	// замена всех вхождений символа
+	fmt.Println(strings.ReplaceAll(str, " ", "_"))
+	// Hi,_my_dear_friend!!!
+
+	// замена подстроки
+	fmt.Println(strings.ReplaceAll(str, "dear", "good"))
+	// Hi, my good friend!!!
+
+	// удаление подстроки или символа
+	fmt.Println(strings.ReplaceAll(str, "dear", ""))
+	// Hi, my  friend!!!
+}

part_1/1.15/8.go

@@ -0,0 +1,13 @@
+package main
+
+import (
+	"fmt"
+	"strings"
+)
+
+func main() {
+	str := "Hi, my dear friend!!!"
+	fmt.Printf("Длина строки: %d\n", len(str)) // Длина строки: 21
+	fmt.Printf("Символов 'i' – %d", strings.Count(str, "i"))
+	// Символов 'i' – 2
+}

part_1/1.15/9.go

@@ -0,0 +1,15 @@
+package main
+
+import (
+	"fmt"
+	"strings"
+)
+
+func main() {
+	str1 := "Hi, my dear friend!!!"
+	str2 := "Hi, my dear friend!!!"
+	str3 := "Hi, my dear friend!!"
+	fmt.Println(strings.Compare(str1, str2)) // 0
+	fmt.Println(strings.Compare(str1, str3)) // 1
+	fmt.Println(strings.Compare(str3, str1)) // –1
+}

part_1/1.16/1.go

@@ -0,0 +1,24 @@
+package main
+
+import (
+	"fmt"
+	"slices"
+)
+
+func main() {
+	mySlice := []int{1, 2, 3, 4, 5, 6, 7}
+
+	// Поэлементно обходим срез в формате индекс:значение
+	fmt.Printf("All: ")
+	for i, v := range slices.All(mySlice) {
+		fmt.Printf(" %d:%d |", i, v)
+	}
+	fmt.Println()
+
+	// Поэлементно обходим срез в обратном порядке
+	fmt.Printf("Backward: ")
+	for i, v := range slices.Backward(mySlice) {
+		fmt.Printf(" %d:%d |", i, v)
+	}
+	fmt.Println()
+}

part_1/1.16/2.go

@@ -0,0 +1,15 @@
+package main
+
+import (
+	"fmt"
+	"slices"
+)
+
+func main() {
+	mySlice := []int{1, 2, 3, 4, 5, 6, 7}
+
+	// Разбиваем срез на подсрезы размером 3
+	for subSlice := range slices.Chunk(mySlice, 3) {
+		fmt.Println(subSlice)
+	}
+}

part_1/1.16/3.go

@@ -0,0 +1,54 @@
+package main
+
+import (
+	"fmt"
+	"slices"
+)
+
+func main() {
+	base := []int{1, 2, 3, 4, 5, 6}
+	fmt.Println("Исходный срез:", base) // Исходный срез: [1 2 3 4 5 6]
+
+	// Вставка элементов в срез в указанную позицию.
+	// В нашем случае, начиная с 3-го индекса вставляем 99 и 100
+	inserted := slices.Insert(base, 3, 99, 100)
+	fmt.Println("Insert: ", inserted) // Insert:  [1 2 3 99 100 4 5 6]
+
+	// Копирование среза
+	cloned := slices.Clone(base)
+	base[0] = 100
+	fmt.Println("Оригинал:", base)   // Оригинал: [100 2 3 4 5 6]
+	fmt.Println("Клон:    ", cloned) // Клон:     [1 2 3 4 5 6]
+
+	// Объединение срезов
+	parts := []int{7, 8, 9}
+	concatenated := slices.Concat(base, parts)
+	fmt.Println("Concat: ", concatenated) //Concat: [100 2 3 4 5 6 7 8 9]
+
+	// Удаляем диапазон с i-го по j-й индекс
+	deleted := slices.Clone(base)
+	deleted = slices.Delete(deleted, 2, 5)
+	fmt.Println("Delete: ", deleted) // Delete:  [100 2 6]
+
+	// Удаляем по условию через лямбда-функцию.
+	// В нашем случае удаляются элементы, у которых значение кратно 2
+	filtered := slices.Clone(base)
+	filtered = slices.DeleteFunc(filtered, func(n int) bool {
+		return n%2 == 0
+	})
+	fmt.Println("DeleteFunc: ", filtered) // DeleteFunc:  [3 5]
+
+	// Повторение среза указанное количество раз (например, 2)
+	repeated := slices.Repeat(base, 2)
+	fmt.Println("Repeat: ", repeated) // [100 2 3 4 5 6 100 2 3 4 5 6]
+
+	// С i-го до j-го индекса значения
+	// элементов поменяются на 97,98,99
+	replaced := slices.Replace(base, 1, 4, 97, 98, 99)
+	fmt.Println("Replace: ", replaced) // Replace:  [100 97 98 99 5 6]
+
+	// Инвертируем порядок элементов среза
+	reversed := slices.Clone(base)
+	slices.Reverse(reversed)
+	fmt.Println("Reverse: ", reversed) // Reverse:  [6 5 99 98 97 100]
+}

part_1/1.16/4.go

@@ -0,0 +1,42 @@
+package main
+
+import (
+	"cmp"
+	"fmt"
+	"slices"
+)
+
+func main() {
+	numbers := []int{5, 2, 6, 3, 1, 4}
+	words := []string{"banana", "apple", "cherry", "date"}
+
+	// Сортировка среза
+	slices.Sort(numbers)
+	fmt.Println("Sort (int):", numbers) // Sort (int): [1 2 3 4 5 6]
+
+	slices.Sort(words)
+	fmt.Println("Sort (string):", words) // [apple banana cherry date]
+
+	// Настраиваемая сортировка через лямбда-функцию
+	mixed := []int{30, 15, 42, 7, 25}
+
+	// Функция должна возвращать:
+	// -1 если первый̆ аргумент меньше второго,
+	// 0 если аргументы равны,
+	// 1 если первый̆ аргумент больше второго
+	// за нас это может рассчитать cmp.Compare
+	slices.SortFunc(mixed, func(a, b int) int {
+		// Сортировка по последней цифре
+		return cmp.Compare(a%10, b%10)
+	})
+	fmt.Println("SortFunc: ", mixed) // SortFunc:  [30 42 15 25 7]
+
+	// Проверка на то, что элементы среза отсортированы
+	sortedCheck := []int{1, 3, 5, 7, 9}
+	fmt.Printf("IsSorted(%v): %t\n", sortedCheck,
+		slices.IsSorted(sortedCheck)) // IsSorted([1 3 5 7 9]): true
+
+	unsortedCheck := []int{2, 1, 3, 4}
+	fmt.Printf("IsSorted(%v): %t\n", unsortedCheck,
+		slices.IsSorted(unsortedCheck)) // IsSorted([2 1 3 4]): false
+}

part_1/1.16/5.go

@@ -0,0 +1,25 @@
+package main
+
+import (
+	"fmt"
+	"slices"
+)
+
+func main() {
+	mySlice := []int{1, 2, 3, 4, 5, 6}
+
+	// BinarySearch принимает на вход срез и значение,
+	// которое нужно найти. Работает только с отсортированными срезами
+	index, found := slices.BinarySearch(mySlice, 4)
+	fmt.Printf("BinarySearch(4): index=%d, found=%t\n", index, found)
+	// BinarySearch(4): index=3, found=true
+
+	index, found = slices.BinarySearch(mySlice, 7)
+	fmt.Printf("BinarySearch(7): index=%d, found=%t\n", index, found)
+	// BinarySearch(7): index=6, found=false
+
+	// Ищем индекс первого вхождения элемента
+	data := []int{5, 2, 5, 3, 5}
+	fmt.Println(slices.Index(data, 5)) // 0
+	fmt.Println(slices.Index(data, 7)) // -1
+}

part_1/1.16/6.go

@@ -0,0 +1,29 @@
+package main
+
+import (
+	"fmt"
+	"slices"
+)
+
+func main() {
+	// Проверка наличия элемента с таким значением в срезе
+	numbers := []int{1, 2, 3, 4, 5}
+	fmt.Println(slices.Contains(numbers, 3)) // true
+	fmt.Println(slices.Contains(numbers, 6)) // false
+
+	// Лексикографическое сравнение срезов
+	a := []int{1, 2, 3}
+	b := []int{1, 2, 4}
+
+	fmt.Println(slices.Compare(a, b)) // -1 (a < b)
+	fmt.Println(slices.Compare(b, a)) // 1 (b > a)
+	fmt.Println(slices.Compare(a, a)) // 0 (equal)
+
+	// Проверка срезов на равенство
+	x := []int{1, 2, 3}
+	y := []int{1, 2, 3}
+	z := []int{3, 2, 1}
+
+	fmt.Println(slices.Equal(x, y)) // true
+	fmt.Println(slices.Equal(x, z)) // false
+}

part_1/1.16/7.go

@@ -0,0 +1,20 @@
+package main
+
+import (
+	"fmt"
+	"slices"
+)
+
+func main() {
+	// Удаление последовательных дубликатов
+	values := []int{1, 1, 2, 3, 3, 3, 4, 5, 5, 6, 1}
+	compacted := slices.Compact(values)
+	fmt.Println("Compact:", compacted) // Compact: [1 2 3 4 5 6 1]
+
+	// Поиск максимума
+	values = []int{5, 2, 9, 1, 7}
+	fmt.Println("Max:", slices.Max(values)) // Max: 9
+
+	// Поиск минимума
+	fmt.Println("Min:", slices.Min(values)) // Min: 1
+}

part_1/1.17/1.go

@@ -0,0 +1,46 @@
+package main
+
+import (
+	"fmt"
+	"maps"
+)
+
+func main() {
+	original := map[string]int{
+		"1": 5,
+		"2": 3,
+		"3": 7,
+	}
+
+	// Создание копии таблицы
+	cloned := maps.Clone(original)
+
+	// Копирование элементов из одной таблицы в другую
+	dest := map[string]int{"x": 1}
+	maps.Copy(dest, original)   // копируем элементы original в dest
+	fmt.Println("Copy: ", dest) // Copy:  map[1:5 2:3 3:7 x:1]
+
+	// Удаление элементов таблицы по условию
+	filtered := maps.Clone(original)
+	maps.DeleteFunc(filtered, func(key string, value int) bool {
+		return value < 5 // удаляем элементы, где значение <5
+	})
+	fmt.Println("DeleteFunc: ", filtered) // DeleteFunc:  map[1:5 3:7]
+
+	// Cравнение таблиц
+	fmt.Println(maps.Equal(original, cloned))   // false
+	fmt.Println(maps.Equal(original, original)) // true
+
+	// Итерация по ключам
+	fmt.Print("Keys: ")
+	for k := range maps.Keys(original) {
+		fmt.Print(" ", k) // Keys:  1 2 3
+	}
+	fmt.Println()
+
+	// Итерация по значениям
+	fmt.Print("Values: ")
+	for v := range maps.Values(original) {
+		fmt.Print(" ", v) // Values:  3 7 5
+	}
+}

part_2/2.1/2.1.1/1.go

@@ -0,0 +1,19 @@
+package main
+
+import "fmt"
+
+func main() {
+	array := [4]float64{2.4, 5.6, 8.1, 9.22}
+	myFunc(array)
+	fmt.Printf("Array in main: %v\n", array)
+}
+
+func myFunc(array [4]float64) {
+	for i := range array {
+		array[i] += 2.33
+	}
+	fmt.Printf("Array in myFunc: %v\n", array)
+}
+
+// Array in myFunc: [4.73 7.93 10.43 11.55]
+// Array in main: [2.4 5.6 8.1 9.22]

part_2/2.1/2.1.1/2.go

@@ -0,0 +1,19 @@
+package main
+
+import "fmt"
+
+func main() {
+	array := [4]float64{2.4, 5.6, 8.1, 9.22}
+	myFunc(&array)
+	fmt.Printf("Array in main: %v\n", array)
+}
+
+func myFunc(array *[4]float64) {
+	for i := range array {
+		array[i] += 2.33
+	}
+	fmt.Printf("Array in myFunc: %v\n", *array)
+}
+
+// Array in myFunc: [4.73 7.93 10.43 11.55]
+// Array in main: [4.73 7.93 10.43 11.55]

part_2/2.1/2.1.1/3.go

@@ -0,0 +1,19 @@
+package main
+
+import "fmt"
+
+func main() {
+	array := []float64{2.4, 5.6, 8.1, 9.22}
+	myFunc(&array)
+	fmt.Printf("Array in main: %v\n", array)
+}
+
+func myFunc(array *[]float64) {
+	for i := range *array {
+		(*array)[i] += 1.5
+	}
+	fmt.Printf("Array in myFunc: %v\n", *array)
+}
+
+// Array in myFunc: [3.9 7.1 9.6 10.72]
+// Array in main: [3.9 7.1 9.6 10.72]

part_2/2.1/2.1.1/4.go

@@ -0,0 +1,15 @@
+package main
+
+import "fmt"
+
+func main() {
+	a, b, rez := 10, 13, 0
+	add(a, b, &rez)
+	fmt.Printf("%d + %d = %d\n", a, b, rez)
+}
+
+func add(a, b int, rez *int) {
+	*rez = a + b
+}
+
+// 10 + 13 = 23

part_2/2.1/2.1.1/5.go

@@ -0,0 +1,35 @@
+package main
+
+import "fmt"
+
+func find1(slice *[]int, value int, check *bool) {
+	*check = false
+	for i := range *slice {
+		if (*slice)[i] == value {
+			*check = true
+			break
+		}
+	}
+}
+
+func find2(slice *[]int, value int) bool {
+	for i := range *slice {
+		if (*slice)[i] == value {
+			return true
+		}
+	}
+	return false
+}
+
+func main() {
+	slice := []int{2, 4, 5, 7, 103, 55}
+	var check bool
+	value := 2
+	find1(&slice, value, &check)
+	fmt.Printf("%d contains in slice? %t\n", value, check)
+	value = 22
+	fmt.Printf("%d contains in slice? %t\n", value, find2(&slice, value))
+}
+
+// 2 contains in slice? true
+// 22 contains in slice? false

part_2/2.1/2.1.10/1.go

@@ -0,0 +1,12 @@
+package main
+
+import "fmt"
+
+func main() {
+	for i := 0; i < 3; i++ {
+		defer fmt.Printf("%d ", i)
+	}
+}
+
+// Finish!
+// 2 1 0

part_2/2.1/2.1.10/2.go

@@ -0,0 +1,13 @@
+package main
+
+import "fmt"
+
+func main() {
+	defer fmt.Printf("%d ", 0)
+	defer fmt.Printf("%d ", 1)
+	defer fmt.Printf("%d ", 2)
+	fmt.Println("Finish!")
+}
+
+// Finish!
+// 2 1 0

part_2/2.1/2.1.10/3.go

@@ -0,0 +1,13 @@
+package main
+
+import "fmt"
+
+func add(a, b int) int {
+	defer fmt.Println("defer") // выполнится перед return
+	fmt.Println("without defer")
+	return a + b
+}
+
+func main() {
+	fmt.Println(add(42, 13))
+}

part_2/2.1/2.1.2/1.go

@@ -0,0 +1,18 @@
+package main
+
+import "fmt"
+
+func myFunc(value map[string]map[string][]int) {
+	fmt.Println(value)
+}
+
+func main() {
+	myMap := map[string]map[string][]int{
+		"a": {"a2": []int{2, 5, 3}},
+		"b": {"bbc": []int{0, 10, 3}},
+		"c": {"alex": []int{}},
+	}
+	myFunc(myMap)
+}
+
+// map[a:map[a2:[2 5 3]] b:map[bbc:[0 10 3]] c:map[alex:[]]]

part_2/2.1/2.1.2/2.go

@@ -0,0 +1,20 @@
+package main
+
+import "fmt"
+
+type MyType map[string]map[string][]int
+
+func myFunc(value MyType) {
+	fmt.Println(value)
+}
+
+func main() {
+	myMap := MyType{
+		"a": {"a2": []int{2, 5, 3}},
+		"b": {"bbc": []int{0, 10, 3}},
+		"c": {"alex": []int{}},
+	}
+	myFunc(myMap)
+}
+
+// map[a:map[a2:[2 5 3]] b:map[bbc:[0 10 3]] c:map[alex:[]]]

part_2/2.1/2.1.3/1.go

@@ -0,0 +1,19 @@
+package main
+
+import "fmt"
+
+var global string = "Global value"
+
+// global := "Global value" // так объявлять нельзя, будет ошибка
+
+func myFunc() {
+	fmt.Println(global)
+}
+
+func main() {
+	fmt.Println(global)
+	myFunc()
+}
+
+// Global value
+// Global value

part_2/2.1/2.1.3/2.go

@@ -0,0 +1,18 @@
+package main
+
+import "fmt"
+
+var global string = "Global value"
+
+func myFunc() {
+	global := 10
+	fmt.Println(global)
+}
+
+func main() {
+	fmt.Println(global)
+	myFunc()
+}
+
+// Global value
+// 10

part_2/2.1/2.1.3/3.go

@@ -0,0 +1,20 @@
+package main
+
+import "fmt"
+
+var global string = "Global value"
+
+func myFunc() {
+	global := 10
+	fmt.Println(global)
+}
+
+func main() {
+	fmt.Println(global)
+	myFunc()
+	if true {
+		local := 20
+		fmt.Println(local)
+	}
+	local = 5 // undefined: local
+}

part_2/2.1/2.1.3/4.go

@@ -0,0 +1,23 @@
+package main
+
+import "fmt"
+
+var global string = "Global value"
+
+func myFunc() {
+	global := 10
+	fmt.Println(global)
+}
+
+func main() {
+	fmt.Println(global) // Global value
+	local := 20
+	{
+		fmt.Println(local) // 20
+		{
+			local := 10
+			fmt.Println(local) // 10
+		}
+		fmt.Println(local) // 20
+	}
+}

part_2/2.1/2.1.4/1.go

@@ -0,0 +1,13 @@
+package main
+
+import "fmt"
+
+func add(a, b int) int {
+	return a + b
+}
+
+func main() {
+	myFunc := add             // var myFunc func(a int, b int) int = add
+	fmt.Println(add(3, 5))    // 8
+	fmt.Println(myFunc(3, 5)) // 8
+}

part_2/2.1/2.1.5/1.go

@@ -0,0 +1,17 @@
+package main
+
+import "fmt"
+
+func add(a, b int) int {
+	return a + b
+}
+
+func sub(c, a, b int, addFunc func(a int, b int) int) int {
+	return c - addFunc(a, b)
+}
+
+func main() {
+	myFunc := add                      // var myFunc func(a int, b int) int = add
+	fmt.Println(sub(4, 3, 10, add))    // -9
+	fmt.Println(sub(4, 3, 10, myFunc)) // -9
+}

part_2/2.1/2.1.5/2.go

@@ -0,0 +1,19 @@
+package main
+
+import "fmt"
+
+type MyFunctionAdd func(a int, b int) int
+
+func add(a, b int) int {
+	return a + b
+}
+
+func sub(c, a, b int, addFunc MyFunctionAdd) int {
+	return c - addFunc(a, b)
+}
+
+func main() {
+	myFunc := add                      // var myFunc func(a int, b int) int = add
+	fmt.Println(sub(4, 3, 10, add))    // -9
+	fmt.Println(sub(4, 3, 10, myFunc)) // -9
+}

part_2/2.1/2.1.6/1.go

@@ -0,0 +1,20 @@
+package main
+
+import "fmt"
+
+type MyFunctionAdd func(a int, b int) int
+
+func sub(c, a, b int, addFunc MyFunctionAdd) int {
+	return c - addFunc(a, b)
+}
+
+func main() {
+	fmt.Println(sub(4, 3, 10, func(a, b int) int {
+		return a + b
+	})) // -9
+
+	myFunc := func(a, b int) int {
+		return a + b
+	}
+	fmt.Println(sub(4, 3, 10, myFunc)) // -9
+}

part_2/2.1/2.1.7/1.go

@@ -0,0 +1,31 @@
+package main
+
+import "fmt"
+
+type microwaveCreator func(dish string, model int) string
+
+var microwaveIndex int = 0
+
+func factory(microwaveName string, power int) microwaveCreator {
+	microwaveIndex++
+	model := fmt.Sprintf("%s-RU-001%d", microwaveName, microwaveIndex)
+	return func(dish string, mode int) string {
+		str := fmt.Sprintf("Микроволновка %s мощностью  %d w Вт,", model, power)
+		str += fmt.Sprintf("греет блюдо %s в режиме %d", dish, mode)
+		return str
+	}
+}
+
+func main() {
+	microwave := factory("Scarlet", 800)
+	fmt.Println(microwave("Суп", 3))
+	fmt.Println(microwave("Пюре", 2))
+	newMicrowave := factory("LG", 1200)
+	fmt.Println(newMicrowave("Плов", 4))
+}
+
+/*
+Микроволновка Scarlet-RU-0011 мощностью  800 w Вт,греет блюдо Суп в режиме 3
+Микроволновка Scarlet-RU-0011 мощностью  800 w Вт,греет блюдо Пюре в режиме 2
+Микроволновка LG-RU-0012 мощностью  1200 w Вт,греет блюдо Плов в режиме 4
+*/

part_2/2.1/2.1.7/2.go

@@ -0,0 +1,23 @@
+package main
+
+import (
+	"fmt"
+	"math"
+)
+
+type MyPow func(value int) int
+
+func degree(degree int) MyPow {
+	return func(value int) int {
+		return int(math.Pow(float64(value), float64(degree)))
+	}
+}
+
+func main() {
+	calculation := degree(3)
+	fmt.Println(calculation(3)) // 27
+	fmt.Println(calculation(4)) // 64
+	calculation = degree(9)
+	fmt.Println(calculation(4)) // 262144
+	fmt.Println(calculation(7)) // 40353607
+}

part_2/2.1/2.1.7/3.go

@@ -0,0 +1,33 @@
+package main
+
+import "fmt"
+
+type InputFunc func(int, int) int
+type OutputFunc func(int) int
+
+func myClosure(a, b int, foo InputFunc) OutputFunc {
+	return func(value int) int {
+		return value - foo(a, b)
+	}
+}
+
+func main() {
+	globalValue := 99
+	mainFunc := func(a, b int) int {
+		globalValue--
+		fmt.Printf("globalValue: %d, ", globalValue)
+		if a < b {
+			return globalValue - a + b
+		}
+		return -globalValue + b*a
+	}
+
+	calculation := myClosure(3, 5, mainFunc)
+	fmt.Println(calculation(3))
+	fmt.Println(calculation(2))
+	calculation = myClosure(6, -2, mainFunc)
+	fmt.Println(calculation(3))
+	fmt.Println(calculation(7))
+
+	fmt.Println("Final globalValue:", globalValue)
+}

part_2/2.1/2.1.8/1.go

@@ -0,0 +1,16 @@
+package main
+
+import "fmt"
+
+func sumElem(slice []int) int {
+	fmt.Println(slice)
+	if len(slice) <= 1 {
+		return slice[0]
+	}
+	return slice[0] + sumElem(slice[1:])
+}
+
+func main() {
+	mySlice := []int{2, 5, 22, 9, 0}
+	fmt.Println(sumElem(mySlice))
+}

part_2/2.1/2.1.8/2.go

@@ -0,0 +1,20 @@
+package main
+
+import "fmt"
+
+func sumElem(slice []int) int {
+	fmt.Println(slice)
+	if len(slice) <= 1 {
+		return slice[0]
+	}
+	return anotherFunction(slice)
+}
+
+func anotherFunction(slice []int) int {
+	return slice[0] + sumElem(slice[1:])
+}
+
+func main() {
+	mySlice := []int{2, 5, 22, 9, 0}
+	fmt.Println(sumElem(mySlice))
+}

part_2/2.1/2.1.9/1.go

@@ -0,0 +1,20 @@
+package main
+
+import "fmt"
+
+func createGenerator(start int, end int) chan int {
+	ch := make(chan int, end-start)
+	go func(ch chan int) {
+		for i := start; i <= end; i++ {
+			ch <- i // помещение значения в канал
+		}
+		close(ch)
+	}(ch)
+	return ch
+}
+
+func main() {
+	for it := range createGenerator(1, 10) {
+		fmt.Printf("%d || ", it)
+	}
+}

part_2/2.1/2.1.9/2.go

@@ -0,0 +1,25 @@
+package main
+
+import "fmt"
+
+func createGenerator(start int, end int) chan int {
+	ch := make(chan int, end-start)
+	go func(ch chan int) {
+		for i := start; i <= end; i++ {
+			ch <- i // помещение значения в канал
+		}
+		close(ch)
+	}(ch)
+	return ch
+}
+
+func main() {
+	generator := createGenerator(4, 8)
+	for {
+		value := <-generator // распаковка значения из канала в переменную
+		fmt.Printf("%d || ", value)
+		if len(generator) <= 0 { // проверка на выход из бесконечного цикла
+			break
+		}
+	}
+}

part_2/2.2/2.2.1-2.2.2/golang/first/go.mod

@@ -0,0 +1,5 @@
+module golang/first
+
+go 1.24
+
+require github.com/google/uuid v1.6.0 // indirect