Jskonst

golang/internal/io_sample/bench.go

@@ -0,0 +1,54 @@
+package io_sample
+
+import (
+	"bufio"
+	"fmt"
+	"io"
+	"os"
+)
+
+// Write file that will emulate io stream
+// it not bytes precise, but close enough
+func WriteFile(size int64, filename string) error {
+	file, err := os.Create(filename)
+	if err != nil {
+		return err
+	}
+	defer file.Close()
+	writer := bufio.NewWriterSize(file, 5)
+	defer writer.Flush()
+	for i := int64(0); i < size; i++ {
+		str := fmt.Sprintf("%d ", i)
+		// if len(str) >= writer.Available() {
+		// 	break
+		// }
+		if _, err := fmt.Fprint(writer, str); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func ReadFile(filename string) (io.ReadCloser, error) {
+	file, err := os.Open(filename)
+	if err != nil {
+		return nil, err
+	}
+	return file, nil
+}
+
+func MyFileReader(reader io.ReadCloser) error {
+	defer reader.Close()
+	rdr := bufio.NewReader(reader)
+	var item int
+	for {
+		_, err := fmt.Fscanf(rdr, "%d ", &item)
+		if err != nil {
+			if err == io.EOF {
+				return nil
+			}
+			return err
+		}
+		fmt.Println(item)
+	}
+}

golang/internal/module2/merge_sort.go

@@ -0,0 +1,72 @@
+package module2
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+	"strconv"
+	"strings"
+)
+
+func Merge(a []int, b []int) []int {
+	var i int = 0
+	var j int = 0
+	merged := make([]int, len(a)+len(b))
+	for k := 0; k < len(merged); k++ {
+		if j >= len(b) || (i < len(a) && a[i] <= b[j]) {
+			merged[k] = a[i]
+			i++
+		} else {
+			merged[k] = b[j]
+			j++
+		}
+	}
+	return merged
+}
+
+func MergeSort(arr []int, l int, r int) []int {
+	if len(arr) <= 1 {
+		return arr
+	}
+	// Находим середину массива
+	m := len(arr) / 2
+	// Сортируем левую и правую половины независимо
+	left := MergeSort(arr[0:m], l, l+m)
+	right := MergeSort(arr[m:], l+m, r)
+	// Сливаем отсортированные половины
+	fmt.Printf("%d %d ", l+1, r)
+	result := Merge(left, right)
+	if len(result) > 0 {
+		fmt.Printf("%d %d\n", result[0], result[len(result)-1])
+	}
+	return result
+}
+
+func MergeTask() {
+	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")
+	line = strings.TrimSuffix(line, " ")
+	str_arr := strings.Split(line, " ")
+	arr := make([]int, n)
+	for idx, val := range str_arr {
+		arr[idx], err = strconv.Atoi(val)
+		if err != nil {
+			panic(err)
+		}
+	}
+	result := MergeSort(arr, 0, len(arr))
+	for idx, val := range result {
+		if idx < len(result)-1 {
+			fmt.Printf("%d ", val)
+		} else {
+			fmt.Printf("%d\n", val)
+		}
+	}
+}

golang/internal/module2/radix.go

@@ -0,0 +1,15 @@
+package module2
+
+import (
+	"fmt"
+)
+
+func Radix() {
+	var n int
+	fmt.Scanln(&n)
+	arr := make([]string, n)
+	for i := 0; i < n; i++ {
+		fmt.Scanln(&arr[i])
+	}
+	fmt.Println(arr)
+}

golang/internal/module4/list.go

@@ -0,0 +1,71 @@
+package module4
+
+import (
+	"errors"
+	"fmt"
+)
+
+type List struct {
+	Head *Item
+	Tail *Item
+	Size int
+}
+
+type Item struct {
+	Value int
+	Next  *Item
+}
+
+func (l *List) Add(item Item) {
+	if l.Size == 0 {
+		l.Head = &item
+	} else {
+		l.Tail.Next = &item
+	}
+	l.Tail = &item
+	l.Size += 1
+}
+
+func (l *List) GetByIndex(index int) (*Item, error) {
+	if index >= l.Size {
+		return nil, errors.New("Index out of bound")
+	}
+	if index == l.Size-1 {
+		return l.Tail, nil
+	}
+	if index == 0 {
+		return l.Head, nil
+	}
+
+	item := l.Head
+	for i := 0; i <= index-1; i++ {
+		item = item.Next
+	}
+	return item, nil
+}
+
+func Sample() {
+	list := List{
+		Head: nil,
+		Tail: nil,
+		Size: 0,
+	}
+	item := Item{
+		Value: 5,
+		Next:  nil,
+	}
+	list.Add(item)
+	list.Add(Item{
+		Value: 6,
+		Next:  nil,
+	})
+	list.Add(Item{
+		Value: 7,
+		Next:  nil,
+	})
+
+	fmt.Println(list.GetByIndex(0))
+	fmt.Println(list.GetByIndex(1))
+	fmt.Println(list.GetByIndex(2))
+
+}

golang/main.go

@@ -3,10 +3,19 @@ package main
 import (
 	"fmt"
 
-	"isuct.ru/informatics2022/internal/module1"
+	"isuct.ru/informatics2022/internal/io_sample"
 )
 
 func main() {
 	fmt.Println("Hello world")
-	module1.Summ()
+	err := io_sample.WriteFile(8096, "test.txt")
+	if err != nil {
+		fmt.Printf("error writing file :%v \n", err)
+	}
+	fmt.Printf("File wrote sucessfully")
+	err = io_sample.ReadFile("test.txt")
+	if err != nil {
+		fmt.Println("error while reading file")
+	}
+
 }

golang/tests/module2/bubble_test.go

@@ -1,4 +1,4 @@
-package module1_test
+package module2_test
 
 import (
 	"io"

golang/tests/module2/merge_sort_test.go

@@ -0,0 +1,114 @@
+package module2_test
+
+import (
+	"bufio"
+	"fmt"
+	"io"
+	"os"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"isuct.ru/informatics2022/internal/module2"
+	m2 "isuct.ru/informatics2022/internal/module2"
+	"isuct.ru/informatics2022/tests/helpers"
+)
+
+func TestMergeSort(t *testing.T) {
+	require := require.New(t)
+	t.Run("Test merge", func(t *testing.T) {
+		expected := []int{1, 2, 3, 4}
+		t.Run("Test merge equal length", func(t *testing.T) {
+			a := []int{1, 3}
+			b := []int{2, 4}
+			result := m2.Merge(a, b)
+			require.EqualValues(expected, result)
+		})
+		t.Run("Test merge first shorter length", func(t *testing.T) {
+			a := []int{1}
+			b := []int{2, 3, 4}
+			result := m2.Merge(a, b)
+			require.EqualValues(expected, result)
+		})
+		t.Run("Test merge second short length", func(t *testing.T) {
+			a := []int{1, 2, 3}
+			b := []int{4}
+			result := m2.Merge(a, b)
+			require.EqualValues(expected, result)
+		})
+	})
+
+	t.Run("Test merge sort", func(t *testing.T) {
+		defer func(v *os.File) { os.Stdin = v }(os.Stdin)
+		defer func(v *os.File) { os.Stdout = v }(os.Stdout)
+
+		t.Run("Test single item array", func(t *testing.T) {
+			r, w := helpers.Replacer(`1
+1
+`, t)
+			os.Stdin = r
+			os.Stdout = w
+
+			module2.MergeTask()
+			w.Close()
+			out, _ := io.ReadAll(r)
+			require.Equal(`1
+`, string(out))
+		})
+		t.Run("Test two items array", func(t *testing.T) {
+			r, w := helpers.Replacer(`2
+3 1
+`, t)
+			os.Stdin = r
+			os.Stdout = w
+
+			module2.MergeTask()
+			w.Close()
+			out, _ := io.ReadAll(r)
+			require.Equal(`1 2 1 3
+1 3
+`, string(out))
+		})
+		t.Run("Test 5 items array", func(t *testing.T) {
+			r, w := helpers.Replacer(`5
+5 4 3 2 1
+`, t)
+			os.Stdin = r
+			os.Stdout = w
+
+			module2.MergeTask()
+			w.Close()
+			out, _ := io.ReadAll(r)
+			require.Equal(`1 2 4 5
+4 5 1 2
+3 5 1 3
+1 5 1 5
+1 2 3 4 5
+`, string(out))
+		})
+		t.Run("Test 100000 items array", func(t *testing.T) {
+			r, w := helpers.Replacer(`10000
+`, t)
+			os.Stdin = r
+			os.Stdout = w
+
+			writer := bufio.NewWriterSize(w, int(10000))
+
+			for i := 9999; i >= 0; i-- {
+				fmt.Fprintf(writer, "%d ", i)
+			}
+			fmt.Fprint(writer, "\n")
+			writer.Flush()
+
+			module2.MergeTask()
+			w.Close()
+			out, _ := io.ReadAll(r)
+			require.Equal(`1 2 4 5
+4 5 1 2
+3 5 1 3
+1 5 1 5
+1 2 3 4 5
+`, string(out))
+		})
+	})
+
+}