Merge branch 'master' of dtelenkov:Home/codewars

go/stepik/course_2/slice/slice.go

@@ -0,0 +1,121 @@
+package main
+
+import (
+	"fmt"
+)
+
+func main() {
+	// foo1()
+	// foo2()
+	// foo3()
+	// maximum()
+	// foo4()
+	foo5()
+}
+
+func foo1() {
+	var cnt, val int
+	var s []int
+	fmt.Scan(&cnt)
+
+	for i := 0; i < cnt; i++ {
+		fmt.Scan(&val)
+		s = append(s, val)
+	}
+
+	fmt.Println(s)
+}
+
+// Ввод слайса
+func foo2() {
+	var n int
+	fmt.Scan(&n)
+
+	buf := make([]int, n)
+
+	for i := 0; i < n; i++ {
+		fmt.Scan(&buf[i])
+	}
+
+	for i := 0; i < n; i++ {
+		if i%3 == 0 {
+			fmt.Print(buf[i], " ")
+		}
+	}
+
+	// fmt.Println(buf)
+}
+
+func foo3() {
+	var n int
+	fmt.Scan(&n)
+
+	buf := make([]int, n)
+
+	for i := 0; i < n; i++ {
+		fmt.Scan(&buf[i])
+	}
+
+	for i := 0; i < n; i++ {
+		if buf[i]%3 == 0 {
+			fmt.Print(buf[i], " ")
+		}
+	}
+}
+
+func maximum() {
+	var n int
+	fmt.Scan(&n)
+
+	numbers := make([]int, n)
+	for i := 0; i < n; i++ {
+		fmt.Scan(&numbers[i])
+	}
+
+	max := numbers[0]
+	maxIndex := 0
+
+	for i := 0; i < n; i++ {
+		if numbers[i] > max {
+			max = numbers[i]
+			maxIndex = i
+		}
+	}
+
+	fmt.Println(max)
+	fmt.Println(maxIndex)
+}
+
+func foo4() {
+	// [строки][столбцы]
+	a := [2][2]string{
+		{"a[0][0]", "a[0][1]"},
+		{"a[1][0]", "a[1][1]"},
+	}
+
+	fmt.Println(a)
+
+	// двумерный слайс чере make
+	s := make([][]int, 2)  // 2 строки
+	s[0] = make([]int, 2)  // 5 столбцов в первой строке
+	s[1] = make([]int, 10) // 10 столбцов во второй строке
+}
+
+func foo5() {
+	numbers := [][]int{
+		{1, 2, 3},
+		{4, 5, 6},
+		{7, 8, 9},
+	}
+
+	rows := 3
+	cols := 3
+
+	for i := 0; i < rows; i++ {
+		fmt.Printf("Строка %d: ", i+1)
+		for j := 0; j < cols; j++ {
+			fmt.Print(numbers[i][j], " ")
+		}
+		fmt.Println()
+	}
+}

go/stepik/course_2/strings/strings.go

@@ -0,0 +1,217 @@
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+	"strings"
+	"time"
+)
+
+func main() {
+	// foo1()
+	// foo2()
+	// foo3()
+	// foo4()
+	// foo5()
+	// foo6()
+	// foo7()
+	// foo8()
+	// foo9()
+	// foo10()
+	foo12()
+}
+
+func foo1() {
+	var val rune
+	fmt.Scanf("%c", &val)
+	// fmt.Println(string(val))
+	if val >= '0' && val <= '9' {
+		fmt.Println("YES")
+	} else {
+		fmt.Println("NO")
+	}
+}
+
+func foo2() {
+	var val rune
+	fmt.Scanf("%c", &val)
+
+	for letter := 'a'; letter <= val; letter++ {
+		fmt.Print(string(letter), " ")
+	}
+}
+
+func foo3() {
+	var val rune
+	fmt.Scanf("%c", &val)
+
+	for letter := val; letter <= 'z'; letter++ {
+		fmt.Print(string(letter), " ")
+	}
+}
+
+func foo4() {
+	var val rune
+	fmt.Scanf("%c", &val)
+
+	if val >= 'A' && val <= 'Z' {
+		fmt.Print(string(val + 32))
+	} else if val >= 'a' && val <= 'z' {
+		fmt.Print(string(val - 32))
+	}
+}
+
+func foo5() {
+	var name string
+	var price float64
+	var amount int
+
+	fmt.Scan(&name, &price, &amount)
+
+	fmt.Printf("Стоимость %s: %g * %d = %g руб.", name, price, amount, price*float64(amount))
+}
+
+func foo6() {
+	scanner := bufio.NewScanner(os.Stdin)
+	scanner.Scan()
+	str := scanner.Text()
+	fmt.Println(strings.Count(str, " ") + 1)
+}
+
+// -----------------------------------------------------
+
+func foo7() {
+	var str string
+	fmt.Scan(&str)
+	s := []rune(str)
+	for i := len(s) - 1; i >= 0; i-- {
+		fmt.Print(string(s[i]))
+	}
+}
+
+// Функция с использованием defer
+func reverseWithDefer(s string) {
+	for _, val := range s {
+		defer func(v rune) {
+			_ = string(v) // вместо вывода
+		}(val)
+	}
+}
+
+// Функция проход с конца
+func reverseWithAccumulation(s string) {
+	for i := len(s) - 1; i >= 0; i-- {
+		_ = string(s[i]) // вместо вывода
+	}
+}
+
+func testSpeed(s string) {
+	start := time.Now()
+	reverseWithDefer(s)
+	durationDefer := time.Since(start)
+	fmt.Println(durationDefer)
+}
+
+// -----------------------------------------------------
+
+func foo8() {
+	/*
+		var position int
+		scanner := bufio.NewScanner(os.Stdin)
+		scanner.Scan()
+		str := scanner.Text()
+		fmt.Scan(&position)
+
+		strRune := []rune(str)
+		for i := 0; i < len(strRune); i++ {
+			if i != position-1 {
+				fmt.Print(string(strRune[i]))
+			}
+		}
+	*/
+	var str string
+	var position int
+	fmt.Scan(&str, &position)
+
+	strRune := []rune(str)
+	for i := 0; i < len(strRune); i++ {
+		if i != position-1 {
+			fmt.Print(string(strRune[i]))
+		}
+	}
+}
+
+func foo9() {
+	/*
+		scanner := bufio.NewScanner(os.Stdin)
+		scanner.Scan()
+		str := scanner.Text()
+		strRune := []rune(str)
+		res := "-1"
+		for i := 0; i < len(strRune); i++ {
+			if strRune[i] == 'x' {
+				res = "x"
+				break
+			}
+			if strRune[i] == 'w' {
+				res = "w"
+				break
+			}
+		}
+		fmt.Println(res)
+	*/
+	var str string
+	fmt.Scan(&str)
+
+	for _, element := range str {
+		if string(element) == "x" || string(element) == "w" {
+			fmt.Println(string(element))
+			return
+		}
+	}
+	fmt.Print(-1)
+}
+
+// Функция палиндром
+func foo10() {
+	var s, rs string
+	fmt.Scan(&s)
+	for i := 0; i < len(s); i++ {
+		rs = string(s[i]) + rs
+	}
+	if rs == s {
+		fmt.Println("YES")
+	} else {
+		fmt.Println("NO")
+	}
+}
+
+// Еще один вариант палиндрома
+func foo11() {
+	scanner := bufio.NewScanner(os.Stdin)
+	scanner.Scan()
+	s := scanner.Text()
+
+	for i := 0; i < len(s)/2; i++ {
+		if s[i] != s[len(s)-1-i] {
+			break
+		}
+	}
+}
+
+// Поиск повторяющейся буквы
+func foo12() {
+	var s string
+	fmt.Scan(&s)
+
+	for i := 0; i < len(s); i++ {
+		simbol := s[i]
+		for j := i + 1; j < len(s); j++ {
+			if simbol == s[j] {
+				fmt.Println(string(simbol))
+				break
+			}
+		}
+	}
+}

go/stepik/course_3/base/embed_interface.go

@@ -0,0 +1,56 @@
+package main
+
+import (
+	"fmt"
+)
+
+// ------------------------
+
+type Payer interface {
+	Pay(int) error
+}
+
+type Ringer interface {
+	Ring(string) error
+}
+
+type NFCPhone interface {
+	Payer
+	Ringer
+}
+
+type Phone struct {
+	Money int
+}
+
+func (p *Phone) Pay(amount int) error {
+	if p.Money < amount {
+		return fmt.Errorf("Не хватает денег на телефоне")
+	}
+	p.Money -= amount
+	return nil
+}
+
+func (p *Phone) Ring(number string) error {
+	if number == "" {
+		return fmt.Errorf("Please, enter phone")
+	}
+	return nil
+}
+
+func PayForMetWithPhone(phone NFCPhone) {
+	err := phone.Pay(1)
+	if err != nil {
+		fmt.Printf("Ошибка при оплате %v\n\n", err)
+		return
+	}
+	fmt.Printf("Турникет открыт через %T\n\n", phone)
+}
+
+// ------------------------
+
+func main() {
+	myPhone := &Phone{Money: 9}
+	PayForMetWithPhone(myPhone)
+
+}

go/stepik/course_3/base/empty_interface.go

@@ -0,0 +1,61 @@
+package main
+
+import (
+	"fmt"
+	"strconv"
+)
+
+func main() {
+	foo1()
+}
+
+type Payer interface {
+	Pay(int) error
+}
+
+type Stringer interface {
+	String() string
+}
+
+type Wallet struct {
+	Cash int
+}
+
+func (w *Wallet) Pay(amount int) error {
+	if w.Cash < amount {
+		return fmt.Errorf("Не хватает денег на кошельке")
+	}
+	w.Cash -= amount
+	return nil
+}
+
+func (w *Wallet) String() string {
+	return "Кошелек в котором " + strconv.Itoa(w.Cash) + " денег"
+}
+
+func Buy(in interface{}) {
+	var p Payer
+	var ok bool
+	if p, ok = in.(Payer); !ok {
+		fmt.Printf("%T не является платежным интерфейсом\n\n", in)
+		return
+	}
+
+	err := p.Pay(10)
+	if err != nil {
+		fmt.Printf("Ошибка при оплате %T: %v\n\n", p, err)
+		return
+	}
+	fmt.Printf("Спасибо за покупку через %T\n\n", p)
+}
+
+func foo1() {
+	myWallet := &Wallet{Cash: 100}
+	// fmt.Printf("Raw payment : %#v\n", myWallet)
+	// fmt.Printf("Способ оплаты: %s\n", myWallet)
+
+	Buy(myWallet)
+	Buy([]int{1, 2, 3})
+	Buy(3.14)
+
+}

go/stepik/course_3/base/example/data_map.txt

@@ -0,0 +1,6 @@
+1
+2
+3
+3
+3
+4

go/stepik/course_3/base/example/main.go

@@ -0,0 +1,52 @@
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"io"
+	"os"
+)
+
+func uniq(input io.Reader, output io.Writer) error {
+	in := bufio.NewScanner(input)
+	var prev string
+	for in.Scan() {
+		txt := in.Text()
+
+		if txt == prev {
+			continue
+		}
+
+		if txt < prev {
+			return fmt.Errorf("file not sorted")
+		}
+
+		prev = txt
+		fmt.Fprintln(output, txt)
+	}
+	return nil
+}
+
+func main() {
+	err := uniq(os.Stdin, os.Stdout)
+	if err != nil {
+		panic(err.Error())
+	}
+
+	/*
+		// Вариант с map плох для больших объемов данных
+		in := bufio.NewScanner(os.Stdin)
+		alreadySeen := make(map[string]bool)
+		for in.Scan() {
+			txt := in.Text()
+
+			if _, found := alreadySeen[txt]; found {
+				continue
+			}
+
+			alreadySeen[txt] = true
+
+			fmt.Println(txt)
+		}
+	*/
+}

go/stepik/course_3/base/example/main_test.go

@@ -0,0 +1,49 @@
+package main
+
+import (
+	"bufio"
+	"bytes"
+	"strings"
+	"testing"
+)
+
+var testOk = `1
+2
+3
+3
+4
+5`
+
+var testOkResult = `1
+2
+3
+4
+5
+`
+
+func TestOk(t *testing.T) {
+
+	in := bufio.NewReader(strings.NewReader(testOk))
+	out := new(bytes.Buffer)
+	err := uniq(in, out)
+	if err != nil {
+		t.Errorf("test for OK Failed - error")
+	}
+	if out.String() != testOkResult {
+		t.Errorf("test for OK Failed - results not match")
+	}
+}
+
+var testFail = `1
+2
+1`
+
+func TestForError(t *testing.T) {
+
+	in := bufio.NewReader(strings.NewReader(testFail))
+	out := new(bytes.Buffer)
+	err := uniq(in, out)
+	if err == nil {
+		t.Errorf("test for Error Failed - error")
+	}
+}

go/stepik/course_3/base/func.go

@@ -0,0 +1,53 @@
+package main
+
+import "fmt"
+
+func main() {
+	// nums := []int{1, 2, 3, 4, 5}
+	// sum(1, 2, 3)
+	// sum(nums...)
+
+	foo1()
+}
+
+// не фиксированное количество параметров
+func sum(in ...int) (result int) {
+	fmt.Printf("in := %#v \n", in)
+	for _, val := range in {
+		result += val
+	}
+	return
+}
+
+func soNothing() {
+	fmt.Println("i'm regular function")
+}
+
+func foo1() {
+	func(in string) {
+		fmt.Println("anaon func out:", in)
+	}("nobody")
+
+	printer := func(in string) {
+		fmt.Println("printer outs:", in)
+	}
+	// printer("as variable")
+
+	// определяем тип функции
+	type strFuncType func(string)
+
+	worker := func(callback strFuncType) {
+		callback("as callback")
+	}
+	worker(printer)
+
+	// функция возвращает замыкание
+	prefixer := func(prefix string) strFuncType {
+		return func(in string) {
+			fmt.Printf("[%s] %s", prefix, in)
+		}
+	}
+	successLogger := prefixer("SUCCESS")
+	successLogger("expecred behaviour")
+
+}

go/stepik/course_3/base/interface.go

@@ -0,0 +1,96 @@
+package main
+
+import "fmt"
+
+func main() {
+	foo1()
+}
+
+type Payer interface {
+	Pay(int) error
+}
+
+// -----------------------------------------------------------------------------
+
+type Wallet struct {
+	Cash int
+}
+
+func (w *Wallet) Pay(amount int) error {
+	if w.Cash < amount {
+		return fmt.Errorf("Не хватает денег в кошельке")
+	}
+	w.Cash -= amount
+	return nil
+}
+
+// -----------------------------------------------------------------------------
+
+type Card struct {
+	Balance    int
+	ValidUntil string
+	Cardholder string
+	CVV        string
+	Number     string
+}
+
+func (c *Card) Pay(amount int) error {
+	if c.Balance < amount {
+		return fmt.Errorf("Не хватает денег на карте")
+	}
+	c.Balance -= amount
+	return nil
+}
+
+// -----------------------------------------------------------------------------
+
+type ApplePay struct {
+	Money   int
+	AppleID string
+}
+
+func (a *ApplePay) Pay(amount int) error {
+	if a.Money < amount {
+		return fmt.Errorf("Не хватает денег на аккаунте")
+	}
+	a.Money -= amount
+	return nil
+}
+
+// -----------------------------------------------------------------------------
+
+// Здесь напрямую нельзя обриться к полю структуры, реализующей интерфейс.
+// Поэтому нужно делать преобразвание.
+func Buy(p Payer) {
+	switch p.(type) {
+	case *Wallet:
+		fmt.Println("Oplata наличными?")
+	case *Card:
+		plasticCard, ok := p.(*Card)
+		if !ok {
+			fmt.Println("Не удалось преобразовать к типу *Card")
+		}
+		fmt.Println("Вставляйте карту,", plasticCard.Cardholder)
+	default:
+		fmt.Println("Что-то новое!")
+	}
+
+	err := p.Pay(10)
+	if err != nil {
+		fmt.Println(err)
+	} else {
+		fmt.Printf("Спасибо за покупку через %T\n\n", p)
+	}
+}
+
+func foo1() {
+	// myWallet := &Wallet{Cash: 100}
+	// Buy(myWallet)
+
+	var myMoney Payer
+	myMoney = &Card{Balance: 100, Cardholder: "rvasily"}
+	Buy(myMoney)
+
+	myMoney = &ApplePay{Money: 9}
+	Buy(myMoney)
+}

go/stepik/course_3/base/panic.go

@@ -0,0 +1,45 @@
+package main
+
+import "fmt"
+
+func main() {
+	// foo1()
+	// foo2()
+	foo3()
+}
+
+func getSomeVars() string {
+	fmt.Println("getSomeVars execution")
+	return "getSomeVars result"
+}
+
+func foo1() {
+	defer fmt.Println("After work")
+	defer fmt.Println(getSomeVars())
+	fmt.Println("Some useful work")
+}
+
+func foo2() {
+	defer fmt.Println("After work")
+	defer func() {
+		fmt.Println(getSomeVars())
+	}()
+	fmt.Println("Some useful work")
+}
+
+// Паника
+func deferTest() {
+	defer func() {
+		if err := recover(); err != nil {
+			fmt.Println("panic happend:", err)
+		}
+	}()
+	fmt.Println("Some useful work")
+	panic("something bad happend")
+	return
+}
+
+func foo3() {
+	deferTest()
+	return
+}

go/stepik/course_3/base/struct.go

@@ -0,0 +1,58 @@
+package main
+
+import "fmt"
+
+type Person struct {
+	Id      int
+	Name    string
+	Address string
+}
+
+type Account struct {
+	Id      int
+	Name    string
+	Cleaner func(string) string
+	Owner   Person
+	Person
+}
+
+func main() {
+	// foo1()
+	foo2()
+}
+
+func foo1() {
+	// полное объявление структуры
+	var acc Account = Account{
+		Id:   1,
+		Name: "rvasily",
+		Person: Person{
+			Address: "Москва",
+		},
+	}
+	// fmt.Printf("%#v\n", acc)
+
+	// короткое объявление структуры
+	acc.Owner = Person{2, "Romanov Vasily", "Moscow"}
+	// fmt.Printf("%#v", acc)
+	fmt.Println(acc.Address)
+}
+
+// методы структур
+
+// не изменяет оригинальной структуры, для который вызван
+// нет смысла
+func (p Person) UpdateName(name string) {
+	p.Name = name
+}
+
+// изменяет оригинальную структура
+func (p *Person) SetName(name string) {
+	p.Name = name
+}
+
+func foo2() {
+	pers := Person{1, "Vasily", "Moscow"}
+	pers.SetName("Vasily Romanov")
+	fmt.Printf("updated person: %#v\n", pers)
+}

go/stepik/course_3/base/task/main.go

@@ -0,0 +1,63 @@
+package main
+
+import (
+	"fmt"
+	"os"
+)
+
+func main() {
+	out := os.Stdout
+
+	// Первый аргумент - путь, второй - опция
+	if !(len(os.Args) == 2 || len(os.Args) == 3) {
+		panic("usage go run main.go . [-f]")
+	}
+
+	path := os.Args[1]
+	printFiles := len(os.Args) == 3 && os.Args[2] == "-f"
+	err := dirTree(out, path, printFiles)
+	if err != nil {
+		panic(err.Error())
+	}
+
+	// fmt.Println(path, printFiles, len(os.Args))
+	// fmt.Printf("%T\n", out, err)
+}
+
+func dirTree(file *os.File, path string, printFiles bool) error {
+	var staticFile = file
+	fmt.Println("Function tree")
+	fmt.Println(file, path, printFiles)
+
+	// Открыть текущую директорию
+	dir, err := os.Open(path)
+	if err != nil {
+		// return err.Error()
+		return err
+	}
+	defer dir.Close()
+
+	// Получаем список файлов и папок
+	files, err := dir.Readdir(-1)
+	if err != nil {
+		return err
+	}
+
+	// Выводим имена файлов и папок
+	for _, file := range files {
+		if file.IsDir() {
+			fmt.Println("Directory: ", file.Name())
+			dirTree(staticFile, path, printFiles)
+		} else {
+			fmt.Println(file.Name())
+		}
+	}
+
+	/*
+		file, err := os.Open("file.go") // For read access.
+		if err != nil {
+			log.Fatal(err)
+		}
+	*/
+	return nil
+}

go/stepik/course_3/base/var.go

@@ -0,0 +1,231 @@
+package main
+
+import "fmt"
+
+func main() {
+	// foo1()
+	// foo2()
+	// foo3()
+	// foo4()
+	// foo5()
+	// foo6()
+	// foo7()
+	foo8()
+}
+
+// строки
+// Строки в Go неизменяемы
+func foo1() {
+
+	// Строка как есть
+	var world string = `Мир\r\n`
+	fmt.Println(world)
+
+	// Одинарный кавычки для байт (uint8)
+	var rawBinary byte = '\x27'
+	fmt.Println(rawBinary)
+	fmt.Println(string(rawBinary))
+
+	// rune (uint32) для UTF-8 символов
+	var someRune rune = 'ℒ'
+	fmt.Println(someRune)
+	fmt.Println(string(someRune))
+
+	// получение подстроки, в байтах, не в символах!
+	var helloWorld string = "Hello world!"
+	hello := helloWorld[:5]
+	fmt.Println(hello)
+
+	// конвертация в слайс байт о обратно
+	byteString := []byte(helloWorld)
+	helloWorld = string(byteString)
+	fmt.Println(byteString)
+	fmt.Println(helloWorld)
+}
+
+// константры
+func foo2() {
+	const pi = 3.14
+
+	// блок констант
+	const (
+		hello = "Привет"
+		e     = 2.718
+	)
+
+	// iota - автоинкремент для констант
+	const (
+		zero  = iota
+		_     // пустая переменная, пропуск iota
+		three // = 3
+	)
+
+	const (
+		// нетипизироанная константа
+		year = 2017
+		// типизированная константа
+		yearTyped int = 2026
+	)
+}
+
+// указатели
+func foo3() {
+	// получение указателя на переменную типа int
+	// инициализированную значением по умолчанию
+	d := new(int)
+
+	fmt.Println(d)
+}
+
+// массивы
+func foo4() {
+	// определение размера при объявлении
+	a1 := [...]int{1, 2, 3}
+	fmt.Println(a1)
+}
+
+// слайсы
+func foo5() {
+	// создание
+	/*
+		var buf0 []int
+		buf1 := []int{}
+		buf2 := []int{42}
+		buf3 := make([]int, 0)     // len = 0, cap = 0
+		buf4 := make([]int, 5)     // len = 5, cap = 5
+		buf5 := make([]int, 5, 10) // len = 5, cap = 10
+	*/
+	// добавление элементов
+	var buf []int
+	buf = append(buf, 9, 10)
+
+	// добавление слайса в слайс
+	otherBuf := make([]int, 3)
+	buf = append(buf, otherBuf...)
+
+	// можно копировать в часть существующего слайса
+	ints := []int{1, 2, 3, 4}
+	copy(ints[1:3], []int{5, 6})
+	fmt.Println(ints)
+}
+
+// map
+func foo6() {
+	// инициализация при создании
+	var user map[string]string = map[string]string{
+		"name":     "Vasily",
+		"lastname": "Romanov",
+	}
+	fmt.Println(user)
+
+	// сразу с нужной емкостью
+	// profile := make(map[string]string, 10)
+
+	// проверка на существование ключа
+	mName, nNameExist := user["middleName"]
+	fmt.Println(mName, nNameExist)
+
+	// удаление ключа
+	delete(user, "lastName")
+}
+
+// условный оператор
+func foo7() {
+	mapVal := map[string]string{"name": "rvasily"}
+
+	// условие с блоком инициализации
+	if keyValue, keyExist := mapVal["name"]; keyExist {
+		fmt.Println("name =", keyValue)
+	}
+
+	// получаем только признак существование ключа
+	if _, keyExist := mapVal["name"]; keyExist {
+		fmt.Println("key 'name' exist")
+	}
+
+	// switch по 1 переменной
+	strVal := "name"
+	switch strVal {
+	case "name":
+		fallthrough // чтобы провалиться в следующее условие
+	case "test", "lastName":
+		// some work
+	default:
+		// some work
+	}
+
+	// switch как замена многим ifelse
+	var val1, val2 = 2, 2
+	switch {
+	case val1 > 1 || val2 < 11:
+		fmt.Println("first block")
+	case val2 > 10:
+		fmt.Println("second block")
+	}
+
+	// выход из цикла, находясь внутри switch 
+Loop:
+	for key, val := range mapVal {
+		fmt.Println("switch in loop", key, val)
+		switch {
+		case key == "lastName":
+			break
+			fmt.Println("dont print this")
+		case key == "firstName" && val == "Vasily":
+			fmt.Println("switch - break loop here")
+			break Loop
+		}
+	} // конце for
+}
+
+// циклы
+func foo8() {
+	// цикл без условия
+	isRun := true
+	for isRun {
+		fmt.Println("loop iteration with condition")
+		isRun = false
+	}
+
+	// операции по slice
+	sl := []int{1, 2, 3}
+	idx := 0
+
+	for idx , len(s1) {
+		fmt.Println("while-type loop, idx:", idx, "value:", sl[idx])
+		idx++
+	}
+
+	for i := 0; i < len(sl); i++ {
+		fmt.Println("c-style loop", i, sl[i])
+	}	
+
+	for idx := range sl {
+		fmt.Println("range slice by index", idx)
+	}
+
+	for idx, val := range sl {
+		fmt.Println("range slice by idx-value", idx, val)
+	}
+
+	// операции по map
+	profile := map[int]string{1: "Vasily", 2: "Romanov"}
+
+	for key := range profile {
+		fmt.Println("range map by key", key)
+	}
+
+	for key, val := range progile {
+		fmt.Println("range map by key-val", key, val)
+	}
+
+	for _, val := range profile {
+		fmt.Println("range map by bal", val)
+	}
+
+	// итерироване по строке
+	str := "Привет, Мир!"
+	for pos, char := range str {
+		fmt.Printf("%#U at pos %d\n" char, pos)
+	}
+}