tmp

go/stepik/1/error.go

@@ -0,0 +1,63 @@
+package main
+
+import (
+	"fmt"
+)
+
+func divide(a int, b int) (int, error) {
+	// return a / b, nil
+	if b == 0 {
+		panic("division by zero!")
+	}
+	return a / b, nil
+}
+
+func test(a int8) {
+	if a == 0 {
+		panic("a = 0; ")
+	}
+}
+
+func saveData() {
+	fmt.Print("Сохраняем данные; ")
+	// ..
+}
+
+func main() {
+
+	/*
+		Если defer находится выше panic, то сначала
+		выполнится defer, а потом паника. Однако, если defer назодится
+		ниже panic, то defer не выполнится вовсе.
+	*/
+
+	defer saveData()
+	fmt.Print("Программа работае; ")
+	test(0)
+	/*
+		var input int
+		_, err := fmt.Scan(&input)
+		if err != nil {
+			fmt.Println("Проверьте типы входных параметров.")
+		} else {
+			fmt.Println(divide(input, 5))
+		}
+	*/
+
+	/*
+		err := errors.New("my error")
+		fmt.Println("", err)
+	*/
+
+	/*
+		var a, b int
+		fmt.Scan(&a, &b)
+		res, err := divide(a, b)
+		if err != nil {
+			fmt.Println("ошибка")
+		} else {
+			fmt.Println(res)
+		}
+	*/
+
+}

go/stepik/1/string_task.go

@@ -1,12 +1,9 @@
 package main
 
 import (
-	"bufio"
 	"fmt"
-	"os"
 	"strings"
 	"unicode"
-	"unicode/utf8"
 )
 
 func main() {
@@ -31,15 +28,105 @@ func main() {
 			fmt.Println("Wrong")
 		}
 	*/
+	/*
+		text, _ := bufio.NewReader(os.Stdin).ReadString('\n')
+		text = strings.TrimRight(text, "\n")
+		firstChar, _ := utf8.DecodeRuneInString(text)
+		lastChar, _ := utf8.DecodeLastRuneInString(text)
+		if unicode.IsUpper(firstChar) && lastChar == '.' {
+			fmt.Println("Right")
+		} else {
+			fmt.Println("Wrong")
+		}
+	*/
+	// poly()
+	// inString()
+	// oddSimbol()
+	// delSimbol()
+	password()
+}
 
-	text, _ := bufio.NewReader(os.Stdin).ReadString('\n')
-	text = strings.TrimRight(text, "\n")
-	firstChar, _ := utf8.DecodeRuneInString(text)
-	lastChar, _ := utf8.DecodeLastRuneInString(text)
-	if unicode.IsUpper(firstChar) && lastChar == '.' {
-		fmt.Println("Right")
+func poly() {
+	/*
+		text, _ := bufio.NewReader(os.Stdin).ReadString('\n')
+		text = strings.TrimRight(text, "\n\r")
+		rs := []rune(text)
+		var res bool = true
+		for i := range rs {
+			// fmt.Println(rs[i], rs[len(rs)-(1+i)])
+			if rs[i] != rs[len(rs)-(1+i)] {
+				res = false
+			}
+			if i == len(rs)/2-1 {
+				break
+			}
+		}
+		if res == true {
+			fmt.Println("Палиндром")
+		} else {
+			fmt.Println("Нет")
+		}
+	*/
+	var s, r string
+	fmt.Scan(&s)
+	for _, i := range s {
+		r = string(i) + r
+	}
+	fmt.Println(r)
+	if s == r {
+		fmt.Println("Палиндром")
 	} else {
-		fmt.Println("Wrong")
+		fmt.Println("Нет")
 	}
+}
+
+func inString() {
+	var x, s string
+	fmt.Scan(&x, &s)
+	fmt.Println(strings.Index(x, s))
+}
 
+func oddSimbol() {
+	var s, newString string
+	fmt.Scan(&s)
+	for i, v := range s {
+		if i%2 != 0 {
+			newString += string(v)
+		}
+	}
+	fmt.Println(newString)
+}
+
+func delSimbol() {
+	var s, newString string
+	fmt.Scan(&s)
+
+	for _, v := range s {
+		if strings.Count(s, string(v)) == 1 {
+			newString += string(v)
+		}
+	}
+	fmt.Println(newString)
+}
+
+func password() {
+	var pas string
+	var res bool = true
+	fmt.Scan(&pas)
+	rpas := []rune(pas)
+	if len(rpas) < 5 {
+		fmt.Println("Wrong password")
+		return
+	}
+	for i := range rpas {
+		if unicode.Is(unicode.Latin, rpas[i]) == false && unicode.IsDigit(rpas[i]) == false {
+			res = false
+			break
+		}
+	}
+	if res == false {
+		fmt.Println("Wrong password")
+	} else {
+		fmt.Println("Ok")
+	}
 }

go/stepik/1/task.go

@@ -0,0 +1,36 @@
+package main
+
+import (
+	"fmt"
+)
+
+func main() {
+	// str1()
+	digit1()
+}
+
+func str1() {
+	var s, ns string
+	fmt.Scan(&s)
+	for i, val := range s {
+		ns += string(val)
+		if i != len(s)-1 {
+			ns += string('*')
+		}
+	}
+	fmt.Println(ns)
+}
+
+func digit1() {
+	var s string
+	fmt.Scan(&s)
+	max := s[0]
+
+	for i := 1; i < len(s); i++ {
+		if s[i] > max {
+			max = s[i]
+		}
+	}
+
+	fmt.Println(string(max))
+}

go/stepik/2/map.go

@@ -0,0 +1,42 @@
+package main
+
+import "fmt"
+
+func main() {
+
+	//s := []map[int]int[uint18]
+	//var s []map[int]int
+	m := make(map[float32]int)
+	//var s []map[int]string{}
+	//var users []string
+	var s = []map[int]string{}
+
+	fmt.Println(s)
+	fmt.Println(m)
+
+	// Создание map с испльзованием встроенной функции make:
+	m1 := make(map[int]int)
+	// m1 := new(map[int]int)
+
+	// Создание и использованием литерала отображения:
+	m2 := map[int]int{
+		12: 2,
+		1:  5,
+	}
+
+	fmt.Println(m1)
+	fmt.Println(m2)
+
+	// Проверка на наличие ключа
+	if value, ok := m2[1]; ok {
+		fmt.Println(value)
+	}
+
+	if value, ok := m2[3]; ok {
+		fmt.Println(value)
+	}
+
+	for key, value := range m2 {
+		fmt.Println(key, value)
+	}
+}

go/stepik/2/map_task.go

@@ -0,0 +1,73 @@
+package main
+
+import "fmt"
+
+func main() {
+	// foo1()
+	// foo2()
+	cities()
+}
+
+func work(x int) int {
+	return x
+}
+
+func foo1() {
+	myMap := make(map[int]int)
+	input := [10]int{}
+	for i := 0; i < 10; i++ {
+		fmt.Scan(&input[i])
+		if value, ok := myMap[input[i]]; ok {
+			// fmt.Println("Value from cache: ", value)
+			fmt.Printf("%d ", value)
+		} else {
+			myMap[input[i]] = work(input[i])
+			// fmt.Println(myMap[input[i]])
+			fmt.Printf("%d ", myMap[input[i]])
+		}
+	}
+}
+
+func foo2() {
+	cache := make(map[int]int, 10)
+	for n, i := 0, 0; i < 10; i++ {
+		fmt.Scan(&n)
+		if _, exists := cache[n]; !exists {
+			cache[n] = work(n)
+		}
+		fmt.Print(cache[n], " ")
+	}
+}
+
+func cities() {
+	groupCity := map[int][]string{
+		10:   []string{"Ивановка", "Грязь"},
+		100:  []string{"Королев", "Электроугли"},
+		1000: []string{"Москва"},
+	}
+
+	cityPopulation := map[string]int{
+		"Королев": 30,
+		"Москва":  200,
+	}
+
+	// fmt.Println(groupCity)
+	// fmt.Println(cityPopulation)
+
+	for pKey, _ := range cityPopulation {
+		//fmt.Println("Searching key", pKey)
+		for cKey, _ := range groupCity {
+			//fmt.Println(cKey, cValue)
+			if cKey != 100 {
+				for _, sValue := range groupCity[cKey] {
+					//fmt.Println(sValue)
+					if sValue == pKey {
+						delete(cityPopulation, pKey)
+					}
+				}
+			}
+		}
+	}
+	fmt.Println("...")
+	fmt.Println(cityPopulation)
+}

go/stepik/2/types.go

@@ -0,0 +1,77 @@
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+	"strconv"
+	"strings"
+	"unicode"
+)
+
+func main() {
+	/*
+		var big int64 = 64
+		var little int8
+
+		little = int8(big)
+		fmt.Println(little)
+		fmt.Printf("%T\n", big)
+	*/
+	// foo1()
+	// fmt.Println(adding("%^80", "hhhhh20&&&&nd"))
+	foo2()
+}
+
+func convert(val int64) uint16 {
+	return uint16(val)
+}
+
+func foo1() {
+	fmt.Println([]rune("stepik"))
+	fmt.Println(string([]byte("stepik")))
+
+	a := 10.123
+	res := int64(a)
+	fmt.Println(res)
+
+	// fmt.Println(int64(10.123))
+	// fmt.Println(101.0 / 10)
+	// fmt.Println(strconv.FormatBool(10 == int(float64(100/10))))
+	// res := (strconv.FormatBool(true)) == (10 == int(float64(100/10)))
+	// fmt.Println(res)
+}
+
+func adding(a, b string) int64 {
+	ar := []rune(a)
+	br := []rune(b)
+	var sa, sb string
+
+	for _, val := range ar {
+		if unicode.IsDigit(val) {
+			sa += string(val)
+		}
+	}
+
+	for _, val := range br {
+		if unicode.IsDigit(val) {
+			sb += string(val)
+		}
+	}
+
+	ia, _ := strconv.Atoi(sa)
+	ib, _ := strconv.Atoi(sb)
+
+	return int64(ia + ib)
+}
+
+func foo2() {
+	scanner := bufio.NewScanner(os.Stdin)
+	scanner.Scan()
+	s := scanner.Text()
+	s = strings.ReplaceAll(strings.ReplaceAll(s, " ", ""), ",", ".")
+	ns := strings.Split(s, ";")
+	a, _ := strconv.ParseFloat(ns[0], 64)
+	b, _ := strconv.ParseFloat(ns[1], 64)
+	fmt.Printf("%.4f", a/b)
+}

go/stepik/3/lambda.go

@@ -0,0 +1,96 @@
+package main
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+	"unicode"
+)
+
+func main() {
+	// ExampleFirstClassFunctionArgument()
+	// ExamplrUseNoNameFunction()
+	// ExampleClosure()
+	foo1()
+}
+
+func invert(r rune) rune {
+	if unicode.IsLower(r) {
+		return unicode.ToUpper(r)
+	}
+	return unicode.ToLower(r)
+}
+
+func ExampleFirstClassFunctionArgument() {
+	src := "aBcDeFg"
+	test := "AbCdEfG"
+
+	// 1. Передача ранее определенной функции
+	// Применяем функцию invert к каждому символу строки src
+	//src = strings.Map(invert, src)
+	//fmt.Printf("Инвертированная строка: %s. Результат: %v.\n", src, src == test)
+
+	// 2. Передача анонимной функции
+	src = strings.Map(func(r rune) rune {
+		if unicode.IsLower(r) {
+			return unicode.ToUpper(r)
+		}
+		return unicode.ToLower(r)
+	}, src)
+	fmt.Printf("Инвертированная строка: %s. Результат: %v.\n", src, src == test)
+}
+
+func ExamplrUseNoNameFunction() {
+	// Присваимваем переменной fn анонимную функцию
+	fn := func(a, b int) int { return a + b }
+
+	// Выполняем анонимную функцию прямо на месте
+	func(a, b int) {
+		fmt.Println(a + b)
+	}(12, 34) // Вызов анонимной функции
+
+	// Выполняем функцию
+	fmt.Println(fn(17, 15))
+	fmt.Printf("%T", fn)
+
+	x := func(fn func(i int) int, i int) func(int) int { return fn }(func(i int) int { return i + 1 }, 5)
+	fmt.Printf("%T", x)
+}
+
+// Более сложный пример замыкания
+func ExampleClosure() {
+	fn := func() func(int) int {
+		count := 0
+		return func(i int) int {
+			count++
+			return count * i
+		}
+	}()
+
+	for i := 1; i <= 5; i++ {
+		fmt.Println(fn(i))
+	}
+}
+
+func foo1() {
+	fn := func(val uint) uint {
+		s := strconv.Itoa(int(val))
+		var newS string
+		for i := 0; i < len(s); i++ {
+			if s[i]%2 == 0 && s[i] != '0' {
+				// fmt.Println(s[i])
+				newS += string(s[i])
+			}
+		}
+		fmt.Println(newS)
+
+		if len(newS) == 0 {
+			return 100
+		} else {
+			res, _ := strconv.Atoi(newS)
+			return uint(res)
+		}
+	}
+
+	fmt.Println(fn(0))
+}