diff --git a/README.md b/README.md index 714ee32..429c3cd 100644 --- a/README.md +++ b/README.md @@ -1,8 +1,7 @@ # Репозиторий для работ по курсу информатика -Вот сюда нужно будет в первой работе с гитом добавит свое ФИО - ## ФИО +Пыжов Виктор Владимирович ## Работа с репозиторием diff --git a/golang/go.mod b/golang/go.mod index be4ab0b..d1cc943 100644 --- a/golang/go.mod +++ b/golang/go.mod @@ -2,4 +2,4 @@ module isuct.ru/informatics2022 go 1.16 -require github.com/stretchr/testify v1.8.1 // indirect +require github.com/stretchr/testify v1.8.1 diff --git a/golang/go.sum b/golang/go.sum index d9320db..2ec90f7 100644 --- a/golang/go.sum +++ b/golang/go.sum @@ -5,12 +5,12 @@ github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZb github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= -github.com/stretchr/objx v0.5.0 h1:1zr/of2m5FGMsad5YfcqgdqdWrIhu+EBEJRhR1U7z/c= github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= github.com/stretchr/testify v1.8.1 h1:w7B6lhMri9wdJUVmEZPGGhZzrYTPvgJArz7wNPgYKsk= github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= diff --git a/golang/internal/module1/task1.go b/golang/internal/module1/task1.go new file mode 100644 index 0000000..916377e --- /dev/null +++ b/golang/internal/module1/task1.go @@ -0,0 +1,9 @@ +package module1 + +import "fmt" + +func Task1() { + var a, b int + fmt.Scanf("%d %d", &a, &b) + fmt.Printf("%d", a+b) +} diff --git a/golang/internal/module1/task2.go b/golang/internal/module1/task2.go new file mode 100644 index 0000000..a3f6a23 --- /dev/null +++ b/golang/internal/module1/task2.go @@ -0,0 +1,10 @@ +package module1 + +import "fmt" + +func Task2() { + var name string + fmt.Scanf("%s", &name) + + fmt.Printf("Hello, %s!", name) +} diff --git a/golang/internal/module2/task1.go b/golang/internal/module2/task1.go new file mode 100644 index 0000000..1fd3944 --- /dev/null +++ b/golang/internal/module2/task1.go @@ -0,0 +1,39 @@ +package module2 + +import ( + "bufio" + "fmt" + "os" + "strconv" + "strings" +) + +func Task1() { + var n int + fmt.Scanln(&n) + + reader := bufio.NewReader(os.Stdin) + line, err := reader.ReadString('\n') + if err != nil { + panic(err) + } + line = strings.TrimSuffix(line, "\n") + line = strings.TrimSuffix(line, "\r") + arr := strings.Split(line, " ") + + p := false + for i := 0; i < n-1; i++ { + for j := 0; j < n-i-1; j++ { + a, _ := strconv.Atoi(arr[j]) + b, _ := strconv.Atoi(arr[j+1]) + if a > b { + arr[j], arr[j+1] = arr[j+1], arr[j] + fmt.Println(strings.Join(arr, " ")) + p = true + } + } + } + if !p { + fmt.Println(0) + } +} diff --git a/golang/internal/module2/task2.go b/golang/internal/module2/task2.go new file mode 100644 index 0000000..8f94955 --- /dev/null +++ b/golang/internal/module2/task2.go @@ -0,0 +1,36 @@ +package module2 + +import ( + "bufio" + "fmt" + "os" + "strconv" + "strings" +) + +func Task2() { + scanner := bufio.NewScanner(os.Stdin) + var n int + fmt.Scanln(&n) + arr := make([][]int, n) + + for i := 0; i < n; i++ { + scanner.Scan() + input := strings.Split(scanner.Text(), " ") + input2 := make([]int, 2) + input2[0], _ = strconv.Atoi(input[0]) + input2[1], _ = strconv.Atoi(input[1]) + arr[i] = input2 + + j := i - 1 + x := arr[i] + for j >= 0 && (arr[j][1] < x[1] || arr[j][1] == x[1] && arr[j][0] > x[0]) { + arr[j+1] = arr[j] + j -= 1 + } + arr[j+1] = x + } + for _, v := range arr { + fmt.Println(v[0], v[1]) + } +} diff --git a/golang/internal/module2/task3.go b/golang/internal/module2/task3.go new file mode 100644 index 0000000..cd72122 --- /dev/null +++ b/golang/internal/module2/task3.go @@ -0,0 +1,62 @@ +package module2 + +import ( + "bufio" + "fmt" + "os" + "strconv" + "strings" +) + +func merge(left, right []int, pos_left int, pos_right int) []int { + result := []int{} + i, j := 0, 0 + for i < len(left) && j < len(right) { + if left[i] <= right[j] { + result = append(result, left[i]) + i++ + } else { + result = append(result, right[j]) + j++ + } + } + result = append(result, left[i:]...) + result = append(result, right[j:]...) + // Описывает осуществление слияния, по одному на каждой строке. По условию задачи. + fmt.Println(pos_left+1, pos_right+len(right), result[0], result[len(result)-1]) + return result +} + +func mergeSort(arr []int, pos int) []int { + if len(arr) <= 1 { + return arr + } + mid := len(arr) / 2 + left := mergeSort(arr[:mid], pos) + right := mergeSort(arr[mid:], pos+mid) + return merge(left, right, pos, pos+mid) +} + +func Task3() { + var n int + fmt.Scanln(&n) + + reader := bufio.NewReader(os.Stdin) + line, err := reader.ReadString('\n') + if err != nil { + panic(err) + } + line = strings.TrimSuffix(line, "\n") + line = strings.TrimSuffix(line, "\r") + arr := strings.Split(line, " ") + + intArr := make([]int, n) + for i := 0; i < n; i++ { + intArr[i], _ = strconv.Atoi(arr[i]) + } + + sortedArr := mergeSort(intArr, 0) + for _, v := range sortedArr { + fmt.Print(v, " ") + } +} diff --git a/golang/internal/module2/task4.go b/golang/internal/module2/task4.go new file mode 100644 index 0000000..ecc2a02 --- /dev/null +++ b/golang/internal/module2/task4.go @@ -0,0 +1,65 @@ +package module2 + +import ( + "bufio" + "fmt" + "os" + "strconv" + "strings" +) + +func merge2(left, right []int) ([]int, int) { + k := 0 + result := []int{} + i, j := 0, 0 + for i < len(left) && j < len(right) { + if left[i] <= right[j] { + result = append(result, left[i]) + i++ + } else { + result = append(result, right[j]) + j++ + k = k + len(left) - i + } + } + result = append(result, left[i:]...) + result = append(result, right[j:]...) + return result, k +} + +func mergeSort2(arr []int, _ int) ([]int, int) { + if len(arr) <= 1 { + return arr, 0 + } + mid := len(arr) / 2 + left, kl := mergeSort2(arr[:mid], 0) + right, kr := mergeSort2(arr[mid:], 0) + a, k := merge2(left, right) + return a, k + kl + kr +} + +func Task4() { + var n int + fmt.Scanln(&n) + + reader := bufio.NewReader(os.Stdin) + line, err := reader.ReadString('\n') + if err != nil { + panic(err) + } + line = strings.TrimSuffix(line, "\n") + line = strings.TrimSuffix(line, "\r") + arr := strings.Split(line, " ") + + intArr := make([]int, len(arr)) + for i, str := range arr { + num, err := strconv.Atoi(str) + if err != nil { + panic(err) + } + intArr[i] = num + } + + _, count := mergeSort2(intArr, 0) + fmt.Println(count) +} diff --git a/golang/internal/module2/task5.go b/golang/internal/module2/task5.go new file mode 100644 index 0000000..2de5bc5 --- /dev/null +++ b/golang/internal/module2/task5.go @@ -0,0 +1,19 @@ +package module2 + +import ( + "fmt" +) + +func Task5() { + var n int + fmt.Scan(&n) + + numbers := make(map[int]bool) + for i := 0; i < n; i++ { + var num int + fmt.Scan(&num) + numbers[num] = true + } + + fmt.Println(len(numbers)) +} diff --git a/golang/internal/module2/task6.go b/golang/internal/module2/task6.go new file mode 100644 index 0000000..8051878 --- /dev/null +++ b/golang/internal/module2/task6.go @@ -0,0 +1,32 @@ +package module2 + +import ( + "fmt" +) + +func Task6() { + var n, k int + fmt.Scan(&n) + products := make([]int, n) + for i := 0; i < n; i++ { + fmt.Scan(&products[i]) + } + + fmt.Scan(&k) + orders := make([]int, k) + for i := 0; i < k; i++ { + fmt.Scan(&orders[i]) + } + + counts := make([]int, n) + for _, v := range orders { + counts[v-1]++ + } + for i := 0; i < n; i++ { + if products[i] < counts[i] { + fmt.Println("yes") + } else { + fmt.Println("no") + } + } +} diff --git a/golang/internal/module2/task7.go b/golang/internal/module2/task7.go new file mode 100644 index 0000000..1f88eaf --- /dev/null +++ b/golang/internal/module2/task7.go @@ -0,0 +1,77 @@ +package module2 + +import ( + "bufio" + "fmt" + "os" + "strconv" +) + +func printArray(arr []string) { + n := len(arr) + if n == 0 { + fmt.Println("empty") + } else { + for i := 0; i < n-1; i++ { + fmt.Printf("%s, ", arr[i]) + } + if n > 0 { + fmt.Println(arr[n-1]) + } + } +} + +func radixSort(arr []string) []string { + maxArr := 0 + for _, s := range arr { + if len(s) > maxArr { + maxArr = len(s) + } + } + + for i := maxArr - 1; i >= 0; i-- { + buckets := make([][]string, 10) + for _, s := range arr { + if len(s) <= i { + buckets[0] = append(buckets[0], s) + } else { + a, _ := strconv.Atoi(string(s[i])) + buckets[a] = append(buckets[a], s) + } + } + + arr = []string{} + for _, bucket := range buckets { + arr = append(arr, bucket...) + } + + fmt.Println("**********") + fmt.Printf("Phase %d\n", maxArr-i) + for j, bucket := range buckets { + fmt.Printf("Bucket %d: ", j) + printArray(bucket) + } + } + + return arr +} + +func Task7() { + scanner := bufio.NewScanner(os.Stdin) + scanner.Scan() + n, _ := strconv.Atoi(scanner.Text()) + arr := make([]string, n) + for i := 0; i < n; i++ { + scanner.Scan() + arr[i] = scanner.Text() + } + + fmt.Println("Initial array:") + printArray(arr) + + sortedArr := radixSort(arr) + + fmt.Println("**********") + fmt.Println("Sorted array:") + printArray(sortedArr) +} diff --git a/golang/internal/module3/task1.go b/golang/internal/module3/task1.go new file mode 100644 index 0000000..54b1774 --- /dev/null +++ b/golang/internal/module3/task1.go @@ -0,0 +1,51 @@ +package module3 + +import "fmt" + +func get_hash(s string, n int, p float64, x float64) float64 { + res := 0.0 + for i := 0; i < n; i++ { + res = (res*x + float64(s[i])) + res = float64(int64(res) % int64(p)) + } + return res +} + +func rabin_karp(s, t string, p float64, x float64) []int { + lent := len(t) + lens := len(s) + ht := get_hash(t, lent, p, x) + hs := get_hash(s, lent, p, x) + xt := 1.0 + for i := 0; i < lent; i++ { + xt *= x + xt = float64(int64(xt) % int64(p)) + } + var res []int + for i := 0; i <= lens-lent; i++ { + if ht == hs { + if s[i:i+lent] == t { + res = append(res, i) + } + } + if i+lent < lens { + hs = (hs*x - float64(int(s[i]))*xt + float64(int(s[i+lent]))) + hs = float64(int64(hs) % int64(p)) + hs = float64(int64(hs+p) % int64(p)) + } + } + return res +} + +func Task1() { + var s, t string + fmt.Scanln(&s) + fmt.Scanln(&t) + p := 1e9 + 7 + x := 26 + res := rabin_karp(s, t, p, float64(x)) + for _, v := range res { + fmt.Printf("%d ", v) + } + fmt.Println() +} diff --git a/golang/internal/module3/task2.go b/golang/internal/module3/task2.go new file mode 100644 index 0000000..45c51cc --- /dev/null +++ b/golang/internal/module3/task2.go @@ -0,0 +1,21 @@ +package module3 + +import "fmt" + +func cyclical_shift(s, t string) int { + n := len(t) + tt := t + t + for i := 0; i < n; i++ { + if tt[i:i+n] == s { + return i + } + } + return -1 +} + +func Task2() { + var s, t string + fmt.Scanln(&s) + fmt.Scanln(&t) + fmt.Println(cyclical_shift(s, t)) +} diff --git a/golang/internal/module3/task3.go b/golang/internal/module3/task3.go new file mode 100644 index 0000000..df7af38 --- /dev/null +++ b/golang/internal/module3/task3.go @@ -0,0 +1,23 @@ +package module3 + +import ( + "fmt" + "strings" +) + +func Task3() { + var s string + fmt.Scan(&s) + + n := len(s) + k := 1 + + for i := 2; i <= n; i++ { + if n%i == 0 { + if strings.Repeat(s[:n/i], i) == s { + k = i + } + } + } + fmt.Println(k) +} diff --git a/golang/internal/module3/task4.go b/golang/internal/module3/task4.go new file mode 100644 index 0000000..528cbed --- /dev/null +++ b/golang/internal/module3/task4.go @@ -0,0 +1,43 @@ +package module3 + +import "fmt" + +func z_func(s string) []int { + n := len(s) + z := make([]int, n) + z[0] = n + l := 0 + r := 0 + for i := 1; i < n; i++ { + if i <= r { + a := r - i + 1 + b := z[i-l] + if a < b { + z[i] = a + } else { + z[i] = b + } + } + for i+z[i] < n && s[z[i]] == s[z[i]+i] { + z[i]++ + } + if i+z[i]-1 > r { + l = i + r = i + z[i] - 1 + } + } + return z +} + +func Task4() { + var s string + fmt.Scanln(&s) + Z := z_func(s) + min := Z[0] + for i := 1; i < len(Z); i++ { + if Z[i] > 0 && Z[i] < min { + min = Z[i] + } + } + fmt.Println(min) +} diff --git a/golang/internal/module3/task4.go.txt b/golang/internal/module3/task4.go.txt new file mode 100644 index 0000000..3503033 --- /dev/null +++ b/golang/internal/module3/task4.go.txt @@ -0,0 +1,49 @@ +package module3 + +import ( + "fmt" + "strings" +) + +func Task4() { + var s string + fmt.Scan(&s) + + // Ищем все вхождения первого символа в строку + firstChar := rune(s[0]) + indexes := make([]int, 0) + for i, c := range s { + if c == firstChar { + indexes = append(indexes, i) + } + } + + // Ищем периодические подстроки, начинающиеся с каждого вхождения + minLength := len(s) + for _, i := range indexes { + sub := s[i:] + index := strings.Index(sub[1:], sub[:1]) + 1 + if index == 0 || index == len(sub)-1 { + continue + } + period := 1 + for j := 1; j < len(sub); j++ { + if sub[j%index] != sub[j] { + period = j + 1 + break + } + } + repetitions := len(sub) / period + if repetitions*period < len(s) && repetitions*period < minLength { + minLength = repetitions * period + } + } + + // Если не нашли периодических подстрок, то строка состоит из повторений одной подстроки + if minLength == len(s) { + fmt.Println(len(s)) + return + } + + fmt.Println(minLength) +} diff --git a/golang/internal/module4/task1.go b/golang/internal/module4/task1.go new file mode 100644 index 0000000..03ce12c --- /dev/null +++ b/golang/internal/module4/task1.go @@ -0,0 +1,35 @@ +package module4 + +import ( + "bufio" + "fmt" + "os" + "strings" +) + +func Task1() { + reader := bufio.NewReader(os.Stdin) + line, err := reader.ReadString('\n') + if err != nil { + panic(err) + } + line = strings.TrimSuffix(line, "\n") + line = strings.TrimSuffix(line, "\r") + arr := strings.Split(line, "") + + open := 0 + closed := 0 + + for _, v := range arr { + if v == "(" { + open++ + } else { + if open == 0 { + closed++ + } else { + open-- + } + } + } + fmt.Println(open + closed) +} diff --git a/golang/internal/module4/task2.go b/golang/internal/module4/task2.go new file mode 100644 index 0000000..9f09c37 --- /dev/null +++ b/golang/internal/module4/task2.go @@ -0,0 +1,68 @@ +package module4 + +type Stack struct { + buffer [101]int + top int +} + +func (s *Stack) push(a int) { + s.top++ + s.buffer[s.top] = a +} + +func (s *Stack) pop() { + s.top-- +} + +func (s *Stack) size() int { + return s.top + 1 +} + +func (s *Stack) empty() bool { + return s.top == -1 +} + +func (s *Stack) clear() { + s.top = -1 +} + +func (s *Stack) back() int { + return s.buffer[s.top] +} + +func Task2() { + + // st := Stack{} + // scanner := bufio.NewScanner(os.Stdin) + // for scanner.Scan() { + // s := scanner.Text() + // if s == "exit" { + // break + // } + // if s == "push" { + // scanner.Scan() + // n, _ := strconv.Atoi(scanner.Text()) + // st.push(n) + // fmt.Println("ok") + // } else if s == "pop" { + // if st.empty() { + // fmt.Println("error") + // } else { + // fmt.Println(st.back()) + // st.pop() + // } + // } else if s == "back" { + // if st.empty() { + // fmt.Println("error") + // } else { + // fmt.Println(st.back()) + // } + // } else if s == "size" { + // fmt.Println(st.size()) + // } else if s == "clear" { + // st.clear() + // fmt.Println("ok") + // } + // } + // fmt.Println("bye") +} diff --git a/golang/internal/module4/task4.go b/golang/internal/module4/task4.go new file mode 100644 index 0000000..2fcf426 --- /dev/null +++ b/golang/internal/module4/task4.go @@ -0,0 +1,55 @@ +package module4 + +import ( + "bufio" + "fmt" + "os" + "strconv" + "strings" +) + +/* +Код использует алгоритм "скользящего окна" с использованием очереди, где каждое новое число добавляется в очередь, +а старое удаляется при переходе окна на следующий шаг. Для нахождения минимума используется список индексов окна, +который сортируется по возрастанию значений в массиве a. Таким образом, первый элемент этого списка - всегда минимальный элемент в текущем окне. +*/ + +func Task4() { + var n, k int + fmt.Scanln(&n, &k) + + reader := bufio.NewReader(os.Stdin) + line, _ := reader.ReadString('\n') + line = strings.TrimSuffix(line, "\n") + line = strings.TrimSuffix(line, "\r") + arr := strings.Split(line, " ") + + intArr := make([]int, n) + for i := 0; i < n; i++ { + intArr[i], _ = strconv.Atoi(arr[i]) + } + + window := make([]int, 0, k) + + for i := 0; i < k; i++ { + for len(window) > 0 && intArr[i] <= intArr[window[len(window)-1]] { + window = window[:len(window)-1] + } + window = append(window, i) + } + + fmt.Println(intArr[window[0]]) + + for i := k; i < n; i++ { + if window[0] <= i-k { + window = window[1:] + } + + for len(window) > 0 && intArr[i] <= intArr[window[len(window)-1]] { + window = window[:len(window)-1] + } + window = append(window, i) + + fmt.Println(intArr[window[0]]) + } +} diff --git a/golang/internal/module5/task1.go b/golang/internal/module5/task1.go new file mode 100644 index 0000000..e162381 --- /dev/null +++ b/golang/internal/module5/task1.go @@ -0,0 +1,30 @@ +package module5 + +import ( + "bufio" + "fmt" + "os" + "strconv" + "strings" +) + +func Task1() { + reader := bufio.NewReader(os.Stdin) + line, _ := reader.ReadString('\n') + line = strings.TrimSuffix(line, "\n") + line = strings.TrimSuffix(line, "\r") + arr := strings.Split(line, " ") + + n := len(arr) - 1 + value := make([]int, n) + for i := 0; i < n; i++ { + value[i], _ = strconv.Atoi(arr[i]) + } + + for i := 0; i < n-2; i++ { + fmt.Println(value[i], value[i+1], value[i+2]) + if value[i] > value[i+1] && value[i] < value[i+1] { + fmt.Println(value[i]) + } + } +} diff --git a/golang/internal/module5/task3.go b/golang/internal/module5/task3.go new file mode 100644 index 0000000..05b7ae5 --- /dev/null +++ b/golang/internal/module5/task3.go @@ -0,0 +1,53 @@ +package module5 + +import ( + "bufio" + "fmt" + "os" + "strconv" + "strings" +) + +func nod(a, b int) int { + if b == 0 { + return a + } + return nod(b, a%b) +} + +func Task3() { + var n, k int + fmt.Scanln(&n) + + reader := bufio.NewReader(os.Stdin) + line, _ := reader.ReadString('\n') + line = strings.TrimSuffix(line, "\n") + line = strings.TrimSuffix(line, "\r") + inputArr := strings.Split(line, " ") + + arr := make([]int, n) + for i := 0; i < n; i++ { + arr[i], _ = strconv.Atoi(inputArr[i]) + } + + fmt.Scanln(&k) + var l, r int + result := make([]int, k) + for i := 0; i < k; i++ { + line, _ = reader.ReadString('\n') + line = strings.TrimSuffix(line, "\n") + line = strings.TrimSuffix(line, "\r") + inputlr := strings.Split(line, " ") + + l, _ = strconv.Atoi(inputlr[0]) + r, _ = strconv.Atoi(inputlr[1]) + + result[i] = arr[l-1] + for j := l; j < r; j++ { + result[i] = nod(result[i], arr[j]) + } + } + for i := 0; i < k; i++ { + fmt.Print(result[i], " ") + } +} diff --git a/golang/main.go b/golang/main.go index 8d32ddc..ff71c9c 100644 --- a/golang/main.go +++ b/golang/main.go @@ -1,12 +1,9 @@ package main import ( - "fmt" - - "isuct.ru/informatics2022/internal/module1" + "isuct.ru/informatics2022/internal/module5" ) func main() { - fmt.Println("Hello world") - module1.Summ() + module5.Task1() } diff --git a/golang/tests/module1/task1_test.go b/golang/tests/module1/task1_test.go new file mode 100644 index 0000000..0f269ea --- /dev/null +++ b/golang/tests/module1/task1_test.go @@ -0,0 +1,48 @@ +package module1_test + +import ( + "io" + "os" + "testing" + + "github.com/stretchr/testify/assert" + "isuct.ru/informatics2022/internal/module1" + "isuct.ru/informatics2022/tests/helpers" +) + +func TestTask1(t *testing.T) { + assert := assert.New(t) + + defer func(v *os.File) { os.Stdin = v }(os.Stdin) + defer func(v *os.File) { os.Stdout = v }(os.Stdout) + t.Run("Case: 10 12", func(t *testing.T) { + r, w := helpers.Replacer("10 12\n", t) + os.Stdin = r + os.Stdout = w + + module1.Task1() + w.Close() + out, _ := io.ReadAll(r) + assert.Equal("22", string(out)) + }) + t.Run("Case: 1 1", func(t *testing.T) { + r, w := helpers.Replacer("1 1\n", t) + os.Stdin = r + os.Stdout = w + + module1.Task1() + w.Close() + out, _ := io.ReadAll(r) + assert.Equal("2", string(out)) + }) + t.Run("Case: 10000 10000", func(t *testing.T) { + r, w := helpers.Replacer("10000 10000\n", t) + os.Stdin = r + os.Stdout = w + + module1.Task1() + w.Close() + out, _ := io.ReadAll(r) + assert.Equal("20000", string(out)) + }) +} diff --git a/golang/tests/module1/task2_test.go b/golang/tests/module1/task2_test.go new file mode 100644 index 0000000..b4f7369 --- /dev/null +++ b/golang/tests/module1/task2_test.go @@ -0,0 +1,38 @@ +package module1_test + +import ( + "io" + "os" + "testing" + + "github.com/stretchr/testify/assert" + "isuct.ru/informatics2022/internal/module1" + "isuct.ru/informatics2022/tests/helpers" +) + +func TestTask2(t *testing.T) { + assert := assert.New(t) + + defer func(v *os.File) { os.Stdin = v }(os.Stdin) + defer func(v *os.File) { os.Stdout = v }(os.Stdout) + t.Run("Case: Vasya", func(t *testing.T) { + r, w := helpers.Replacer("Vasya\n", t) + os.Stdin = r + os.Stdout = w + + module1.Task2() + w.Close() + out, _ := io.ReadAll(r) + assert.Equal("Hello, Vasya!", string(out)) + }) + t.Run("Case: Petya", func(t *testing.T) { + r, w := helpers.Replacer("Petya\n", t) + os.Stdin = r + os.Stdout = w + + module1.Task2() + w.Close() + out, _ := io.ReadAll(r) + assert.Equal("Hello, Petya!", string(out)) + }) +} diff --git a/golang/tests/module2/task1_test.go b/golang/tests/module2/task1_test.go new file mode 100644 index 0000000..ebf3688 --- /dev/null +++ b/golang/tests/module2/task1_test.go @@ -0,0 +1,36 @@ +package module2_test + +import ( + "io" + "os" + "testing" + + "github.com/stretchr/testify/assert" + "isuct.ru/informatics2022/internal/module2" + "isuct.ru/informatics2022/tests/helpers" +) + +func TestTask1(t *testing.T) { + assert := assert.New(t) + + defer func(v *os.File) { os.Stdin = v }(os.Stdin) + defer func(v *os.File) { os.Stdout = v }(os.Stdout) + t.Run("Case: 4 3 2 1", func(t *testing.T) { + r, w := helpers.Replacer(`4 +4 3 2 1 +`, t) + os.Stdin = r + os.Stdout = w + + module2.Task1() + w.Close() + out, _ := io.ReadAll(r) + assert.Equal(`3 4 2 1 +3 2 4 1 +3 2 1 4 +2 3 1 4 +2 1 3 4 +1 2 3 4 +`, string(out)) + }) +} diff --git a/golang/tests/module2/task2_test.go b/golang/tests/module2/task2_test.go new file mode 100644 index 0000000..0fe4a83 --- /dev/null +++ b/golang/tests/module2/task2_test.go @@ -0,0 +1,52 @@ +package module2_test + +import ( + "io" + "os" + "testing" + + "github.com/stretchr/testify/assert" + "isuct.ru/informatics2022/internal/module2" + "isuct.ru/informatics2022/tests/helpers" +) + +func TestTask2(t *testing.T) { + assert := assert.New(t) + + defer func(v *os.File) { os.Stdin = v }(os.Stdin) + defer func(v *os.File) { os.Stdout = v }(os.Stdout) + t.Run("Case: 3 101 80", func(t *testing.T) { + r, w := helpers.Replacer(`3 +101 80 +305 90 +200 14 +`, t) + os.Stdin = r + os.Stdout = w + + module2.Task2() + w.Close() + out, _ := io.ReadAll(r) + assert.Equal(`305 90 +101 80 +200 14 +`, string(out)) + }) + t.Run("Case: 3 20 80", func(t *testing.T) { + r, w := helpers.Replacer(`3 +20 80 +30 90 +25 90 +`, t) + os.Stdin = r + os.Stdout = w + + module2.Task2() + w.Close() + out, _ := io.ReadAll(r) + assert.Equal(`25 90 +30 90 +20 80 +`, string(out)) + }) +} diff --git a/golang/tests/module2/task3_test.go b/golang/tests/module2/task3_test.go new file mode 100644 index 0000000..3139764 --- /dev/null +++ b/golang/tests/module2/task3_test.go @@ -0,0 +1,59 @@ +package module2_test + +import ( + "io" + "os" + "testing" + + "github.com/stretchr/testify/assert" + "isuct.ru/informatics2022/internal/module2" + "isuct.ru/informatics2022/tests/helpers" +) + +func TestTask3(t *testing.T) { + assert := assert.New(t) + + defer func(v *os.File) { os.Stdin = v }(os.Stdin) + defer func(v *os.File) { os.Stdout = v }(os.Stdout) + t.Run("Case: 1 1", func(t *testing.T) { + r, w := helpers.Replacer(`1 +1 +`, t) + os.Stdin = r + os.Stdout = w + + module2.Task3() + w.Close() + out, _ := io.ReadAll(r) + assert.Equal(`1 `, string(out)) + }) + t.Run("Case: 2 3 1", func(t *testing.T) { + r, w := helpers.Replacer(`2 +3 1 +`, t) + os.Stdin = r + os.Stdout = w + + module2.Task3() + w.Close() + out, _ := io.ReadAll(r) + assert.Equal(`1 2 1 3 +1 3 `, string(out)) + }) + t.Run("Case: 5 5 4 3 2 1", func(t *testing.T) { + r, w := helpers.Replacer(`5 +5 4 3 2 1 +`, t) + os.Stdin = r + os.Stdout = w + + module2.Task3() + w.Close() + out, _ := io.ReadAll(r) + assert.Equal(`1 2 4 5 +4 5 1 2 +3 5 1 3 +1 5 1 5 +1 2 3 4 5 `, string(out)) + }) +} diff --git a/golang/tests/module2/task7_test.go b/golang/tests/module2/task7_test.go new file mode 100644 index 0000000..9453e21 --- /dev/null +++ b/golang/tests/module2/task7_test.go @@ -0,0 +1,67 @@ +package module2_test + +import ( + "io" + "os" + "testing" + + "github.com/stretchr/testify/assert" + "isuct.ru/informatics2022/internal/module2" + "isuct.ru/informatics2022/tests/helpers" +) + +func TestTask7(t *testing.T) { + assert := assert.New(t) + + defer func(v *os.File) { os.Stdin = v }(os.Stdin) + defer func(v *os.File) { os.Stdout = v }(os.Stdout) + t.Run("Case: 9 12 32 45 67 98 29 61 35 09", func(t *testing.T) { + r, w := helpers.Replacer(`9 +12 +32 +45 +67 +98 +29 +61 +35 +09 +`, t) + os.Stdin = r + os.Stdout = w + + module2.Task7() + w.Close() + out, _ := io.ReadAll(r) + assert.Equal(`Initial array: +12, 32, 45, 67, 98, 29, 61, 35, 09 +********** +Phase 1 +Bucket 0: empty +Bucket 1: 61 +Bucket 2: 12, 32 +Bucket 3: empty +Bucket 4: empty +Bucket 5: 45, 35 +Bucket 6: empty +Bucket 7: 67 +Bucket 8: 98 +Bucket 9: 29, 09 +********** +Phase 2 +Bucket 0: 09 +Bucket 1: 12 +Bucket 2: 29 +Bucket 3: 32, 35 +Bucket 4: 45 +Bucket 5: empty +Bucket 6: 61, 67 +Bucket 7: empty +Bucket 8: empty +Bucket 9: 98 +********** +Sorted array: +09, 12, 29, 32, 35, 45, 61, 67, 98 +`, string(out)) + }) +} diff --git a/golang/tests/module3/task1_test.go b/golang/tests/module3/task1_test.go new file mode 100644 index 0000000..fc30b79 --- /dev/null +++ b/golang/tests/module3/task1_test.go @@ -0,0 +1,31 @@ +package module3_test + +import ( + "io" + "os" + "testing" + + "github.com/stretchr/testify/assert" + "isuct.ru/informatics2022/internal/module3" + "isuct.ru/informatics2022/tests/helpers" +) + +func TestTask1(t *testing.T) { + assert := assert.New(t) + + defer func(v *os.File) { os.Stdin = v }(os.Stdin) + defer func(v *os.File) { os.Stdout = v }(os.Stdout) + t.Run("Case: ababbababa-aba", func(t *testing.T) { + r, w := helpers.Replacer(`ababbababa +aba +`, t) + os.Stdin = r + os.Stdout = w + + module3.Task1() + w.Close() + out, _ := io.ReadAll(r) + assert.Equal(`0 5 7 +`, string(out)) + }) +} diff --git a/golang/tests/module3/task3_test.go b/golang/tests/module3/task3_test.go new file mode 100644 index 0000000..47935fc --- /dev/null +++ b/golang/tests/module3/task3_test.go @@ -0,0 +1,68 @@ +package module3_test + +import ( + "io" + "os" + "testing" + + "github.com/stretchr/testify/assert" + "isuct.ru/informatics2022/internal/module3" + "isuct.ru/informatics2022/tests/helpers" +) + +func TestTask3(t *testing.T) { + assert := assert.New(t) + + defer func(v *os.File) { os.Stdin = v }(os.Stdin) + defer func(v *os.File) { os.Stdout = v }(os.Stdout) + t.Run("Case: 1-aaaaa", func(t *testing.T) { + r, w := helpers.Replacer(`aaaaa +`, t) + os.Stdin = r + os.Stdout = w + + module3.Task3() + w.Close() + out, _ := io.ReadAll(r) + assert.Equal(`5 +`, string(out)) + }) + + t.Run("Case: 2-abcabcabc", func(t *testing.T) { + r, w := helpers.Replacer(`abcabcabc +`, t) + os.Stdin = r + os.Stdout = w + + module3.Task3() + w.Close() + out, _ := io.ReadAll(r) + assert.Equal(`3 +`, string(out)) + }) + + t.Run("Case: 3-abab", func(t *testing.T) { + r, w := helpers.Replacer(`abab +`, t) + os.Stdin = r + os.Stdout = w + + module3.Task3() + w.Close() + out, _ := io.ReadAll(r) + assert.Equal(`2 +`, string(out)) + }) + t.Run("Case: 17-babbbabb", func(t *testing.T) { + r, w := helpers.Replacer(`babbbabb +`, t) + os.Stdin = r + os.Stdout = w + + module3.Task3() + w.Close() + out, _ := io.ReadAll(r) + assert.Equal(`2 +`, string(out)) + }) +} diff --git a/golang/tests/module4/task2_test.go b/golang/tests/module4/task2_test.go new file mode 100644 index 0000000..40dd9a4 --- /dev/null +++ b/golang/tests/module4/task2_test.go @@ -0,0 +1,59 @@ +package module4_test + +import ( + "io" + "os" + "testing" + + "github.com/stretchr/testify/assert" + "isuct.ru/informatics2022/internal/module4" + "isuct.ru/informatics2022/tests/helpers" +) + +func TestTask2(t *testing.T) { + assert := assert.New(t) + + defer func(v *os.File) { os.Stdin = v }(os.Stdin) + defer func(v *os.File) { os.Stdout = v }(os.Stdout) + t.Run("Case: 3 2 1", func(t *testing.T) { + r, w := helpers.Replacer(`3 +3 2 1 +`, t) + os.Stdin = r + os.Stdout = w + + module4.Task2() + w.Close() + out, _ := io.ReadAll(r) + assert.Equal(`YES +`, string(out)) + }) + + t.Run("Case: 4 1 3 2", func(t *testing.T) { + r, w := helpers.Replacer(`4 +4 1 3 2 +`, t) + os.Stdin = r + os.Stdout = w + + module4.Task2() + w.Close() + out, _ := io.ReadAll(r) + assert.Equal(`YES +`, string(out)) + }) + + t.Run("Case: 2 3 1", func(t *testing.T) { + r, w := helpers.Replacer(`3 +2 3 1 +`, t) + os.Stdin = r + os.Stdout = w + + module4.Task2() + w.Close() + out, _ := io.ReadAll(r) + assert.Equal(`NO +`, string(out)) + }) +}