tmp

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

@@ -1,11 +1,25 @@
 package main
 
 import (
+	"bufio"
 	"fmt"
+	"os"
+	"strings"
+	"time"
 )
 
 func main() {
-	foo1()
+	// foo1()
+	// foo2()
+	// foo3()
+	// foo4()
+	// foo5()
+	// foo6()
+	// foo7()
+	// foo8()
+	// foo9()
+	// foo10()
+	foo12()
 }
 
 func foo1() {
@@ -18,3 +32,186 @@ func foo1() {
 		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/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/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/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)
+	}
+}