├── .github ├── FUNDING.yml ├── ISSUE_TEMPLATE │ ├── bug_report.md │ └── feature_request.md ├── dependabot.yml ├── semantic.yml └── workflows │ └── tests.yml ├── .gitignore ├── .golangci.yml ├── CODE_OF_CONDUCT.md ├── CONTRIBUTING.md ├── LICENSE ├── Makefile ├── README.md ├── SECURITY.md ├── codewars ├── mergesort_merge_function │ ├── README.md │ ├── solution.go │ └── solution_test.go └── weird_string_case │ ├── README.md │ ├── solution.go │ └── solution_test.go ├── docs └── hero-image.jpg ├── go.mod ├── leetcode ├── 1 │ ├── README.md │ ├── solution.go │ └── solution_test.go ├── 15 │ ├── README.md │ ├── solution.go │ └── solution_test.go ├── 19 │ ├── README.md │ ├── solution.go │ └── solution_test.go ├── 33 │ ├── README.md │ ├── solution.go │ └── solution_test.go ├── 56 │ ├── README.md │ ├── solution.go │ └── solution_test.go ├── 66 │ ├── README.md │ ├── solution.go │ └── solution_test.go ├── 88 │ ├── README.md │ ├── solution.go │ └── solution_test.go ├── 155 │ ├── README.md │ ├── solution.go │ └── solution_test.go ├── 167 │ ├── README.md │ ├── solution.go │ └── solution_test.go ├── 328 │ ├── README.md │ ├── solution.go │ └── solution_test.go └── 347 │ ├── README.md │ ├── solution.go │ └── solution_test.go ├── yandex_practicum ├── sprint_1 │ ├── final │ │ ├── A │ │ │ ├── README.md │ │ │ ├── input.txt │ │ │ ├── task.go │ │ │ └── task_test.go │ │ └── B │ │ │ ├── README.md │ │ │ ├── input.txt │ │ │ ├── task.go │ │ │ └── task_test.go │ └── tasks │ │ ├── A │ │ ├── README.md │ │ ├── input.txt │ │ └── task.go │ │ ├── B │ │ ├── README.md │ │ ├── input.txt │ │ └── task.go │ │ ├── C │ │ ├── README.md │ │ └── input.txt │ │ ├── D │ │ ├── README.md │ │ └── input.txt │ │ ├── E │ │ ├── README.md │ │ ├── input.txt │ │ └── task.go │ │ ├── F │ │ ├── README.md │ │ ├── input.txt │ │ └── task.go │ │ ├── G │ │ ├── README.md │ │ └── task.go │ │ ├── H │ │ ├── README.md │ │ └── task.go │ │ ├── I │ │ ├── README.md │ │ └── task.go │ │ ├── J │ │ ├── README.md │ │ └── task.go │ │ ├── K │ │ └── README.md │ │ └── L │ │ ├── README.md │ │ └── task.go ├── sprint_2 │ ├── final │ │ ├── A │ │ │ ├── README.md │ │ │ ├── input.txt │ │ │ ├── task.go │ │ │ └── task_test.go │ │ └── B │ │ │ ├── README.md │ │ │ ├── input.txt │ │ │ ├── task.go │ │ │ └── task_test.go │ └── tasks │ │ ├── A │ │ ├── README.md │ │ ├── input.txt │ │ ├── task.go │ │ └── task_test.go │ │ ├── B │ │ ├── README.md │ │ └── task.go │ │ ├── C │ │ ├── README.md │ │ └── task.go │ │ ├── D │ │ ├── README.md │ │ └── task.go │ │ ├── E │ │ ├── README.md │ │ └── task.go │ │ ├── F │ │ ├── README.md │ │ ├── input.txt │ │ ├── task.go │ │ └── task_test.go │ │ ├── G │ │ ├── README.md │ │ ├── input.txt │ │ ├── task.go │ │ └── task_test.go │ │ ├── H │ │ ├── README.md │ │ ├── input.txt │ │ ├── task.go │ │ └── task_test.go │ │ ├── I │ │ ├── README.md │ │ ├── input.txt │ │ ├── task.go │ │ └── task_test.go │ │ ├── J │ │ ├── README.md │ │ ├── input.txt │ │ ├── task.go │ │ └── task_test.go │ │ ├── K │ │ ├── README.md │ │ ├── task.go │ │ └── task_test.go │ │ └── L │ │ ├── README.md │ │ ├── task.go │ │ └── task_test.go ├── sprint_3 │ ├── final │ │ ├── A │ │ │ ├── README.md │ │ │ ├── input.txt │ │ │ ├── task.go │ │ │ └── task_test.go │ │ └── B │ │ │ ├── README.md │ │ │ ├── input.txt │ │ │ ├── task.go │ │ │ └── task_test.go │ └── tasks │ │ ├── A │ │ ├── README.md │ │ ├── task.go │ │ └── task_test.go │ │ ├── B │ │ ├── README.md │ │ ├── task.go │ │ └── task_test.go │ │ ├── C │ │ ├── README.md │ │ ├── input.txt │ │ ├── task.go │ │ └── task_test.go │ │ ├── D │ │ ├── README.md │ │ ├── input.txt │ │ ├── task.go │ │ └── task_test.go │ │ ├── E │ │ ├── README.md │ │ ├── task.go │ │ └── task_test.go │ │ ├── F │ │ ├── README.md │ │ ├── task.go │ │ └── task_test.go │ │ ├── G │ │ ├── README.md │ │ ├── input.txt │ │ ├── task.go │ │ └── task_test.go │ │ ├── H │ │ ├── README.md │ │ ├── input.txt │ │ ├── task.go │ │ └── task_test.go │ │ ├── I │ │ ├── README.md │ │ ├── task.go │ │ └── task_test.go │ │ ├── J │ │ ├── README.md │ │ ├── input.txt │ │ ├── task.go │ │ └── task_test.go │ │ ├── K │ │ ├── README.md │ │ ├── input.txt │ │ ├── task.go │ │ └── task_test.go │ │ ├── L │ │ ├── README.md │ │ ├── input.txt │ │ ├── task.go │ │ └── task_test.go │ │ ├── M │ │ ├── README.md │ │ ├── task.go │ │ └── task_test.go │ │ ├── N │ │ ├── README.md │ │ ├── task.go │ │ └── task_test.go │ │ ├── O │ │ ├── README.md │ │ ├── task.go │ │ └── task_test.go │ │ └── P │ │ ├── README.md │ │ ├── input.txt │ │ ├── task.go │ │ └── task_test.go ├── sprint_4 │ ├── final │ │ ├── A │ │ │ ├── README.md │ │ │ ├── input.txt │ │ │ ├── task.go │ │ │ └── task_test.go │ │ └── B │ │ │ ├── README.md │ │ │ ├── input.txt │ │ │ ├── task.go │ │ │ └── task_test.go │ └── tasks │ │ ├── A │ │ ├── README.md │ │ ├── input.txt │ │ └── task.go │ │ ├── B │ │ └── README.md │ │ ├── C │ │ ├── README.md │ │ ├── input.txt │ │ └── task.go │ │ ├── D │ │ ├── README.md │ │ ├── input.txt │ │ └── task.go │ │ ├── E │ │ ├── README.md │ │ ├── input.txt │ │ └── task.go │ │ ├── F │ │ └── README.md │ │ ├── G │ │ ├── README.md │ │ ├── input.txt │ │ └── task.go │ │ ├── H │ │ ├── README.md │ │ ├── input.txt │ │ └── task.go │ │ ├── I │ │ ├── README.md │ │ ├── input.txt │ │ └── task.go │ │ ├── J │ │ ├── README.md │ │ ├── input.txt │ │ └── task.go │ │ ├── K │ │ └── README.md │ │ └── L │ │ └── README.md ├── sprint_5 │ ├── final │ │ ├── A │ │ │ ├── README.md │ │ │ ├── task.go │ │ │ └── task_test.go │ │ └── B │ │ │ ├── README.md │ │ │ ├── task.go │ │ │ └── task_test.go │ └── tasks │ │ ├── A │ │ ├── README.md │ │ ├── for_tests.txt │ │ ├── img.png │ │ └── task.go │ │ ├── B │ │ ├── README.md │ │ ├── for tests.txt │ │ ├── image.png │ │ └── task.go │ │ ├── C │ │ ├── README.md │ │ ├── for tests.txt │ │ ├── image.png │ │ └── task.go │ │ ├── D │ │ ├── README.md │ │ └── image.png │ │ ├── E │ │ ├── README.md │ │ └── image.png │ │ ├── F │ │ ├── README.md │ │ ├── for tests.txt │ │ ├── image.png │ │ └── task.go │ │ ├── G │ │ ├── README.md │ │ └── img.png │ │ ├── H │ │ ├── README.md │ │ └── image.png │ │ ├── I │ │ └── README.md │ │ ├── J │ │ ├── README.md │ │ ├── for tests.txt │ │ ├── image.png │ │ └── task.go │ │ ├── K │ │ ├── README.md │ │ ├── for tests.txt │ │ ├── image.png │ │ └── task.go │ │ ├── L │ │ ├── README.md │ │ ├── for tests.txt │ │ ├── image.png │ │ └── task.go │ │ ├── M │ │ ├── README.md │ │ ├── for tests.txt │ │ ├── image.png │ │ └── task.go │ │ └── N │ │ ├── README.md │ │ ├── for tests.txt │ │ └── task.go ├── sprint_6 │ ├── final │ │ ├── A │ │ │ ├── README.md │ │ │ ├── task.go │ │ │ └── task_test.go │ │ └── B │ │ │ ├── README.md │ │ │ ├── task.go │ │ │ └── task_test.go │ └── tasks │ │ ├── A │ │ ├── README.md │ │ ├── task.go │ │ └── task_test.go │ │ ├── B │ │ ├── README.md │ │ ├── task.go │ │ └── task_test.go │ │ ├── C │ │ ├── README.md │ │ ├── task.go │ │ └── task_test.go │ │ ├── D │ │ ├── README.md │ │ ├── task.go │ │ └── task_test.go │ │ ├── E │ │ ├── README.md │ │ ├── task.go │ │ └── task_test.go │ │ ├── F │ │ ├── README.md │ │ ├── task.go │ │ └── task_test.go │ │ ├── G │ │ ├── README.md │ │ ├── task.go │ │ └── task_test.go │ │ ├── H │ │ ├── README.md │ │ ├── task.go │ │ └── task_test.go │ │ ├── J │ │ ├── README.md │ │ ├── task.go │ │ └── task_test.go │ │ ├── K │ │ ├── README.md │ │ ├── task.go │ │ └── task_test.go │ │ ├── L │ │ ├── README.md │ │ ├── task.go │ │ └── task_test.go │ │ └── M │ │ ├── README.md │ │ ├── img.png │ │ ├── task.go │ │ └── task_test.go ├── sprint_7 │ ├── final │ │ ├── A │ │ │ ├── README.md │ │ │ ├── task.go │ │ │ └── task_test.go │ │ └── B │ │ │ ├── README.md │ │ │ ├── task.go │ │ │ └── task_test.go │ └── tasks │ │ ├── A │ │ ├── README.md │ │ ├── task.go │ │ └── task_test.go │ │ ├── B │ │ └── README.md │ │ ├── C │ │ ├── README.md │ │ ├── task.go │ │ └── task_test.go │ │ ├── D │ │ ├── README.md │ │ ├── task.go │ │ └── task_test.go │ │ ├── E │ │ ├── README.md │ │ ├── task.go │ │ └── task_test.go │ │ ├── F │ │ ├── README.md │ │ ├── task.go │ │ └── task_test.go │ │ ├── G │ │ └── README.md │ │ ├── H │ │ ├── README.md │ │ ├── task.go │ │ └── task_test.go │ │ ├── I │ │ └── README.md │ │ ├── J │ │ └── README.md │ │ ├── K │ │ └── README.md │ │ ├── L │ │ ├── README.md │ │ ├── task.go │ │ └── task_test.go │ │ ├── M │ │ ├── README.md │ │ ├── task.go │ │ └── task_test.go │ │ ├── N │ │ └── README.md │ │ └── O │ │ ├── README.md │ │ ├── task.go │ │ └── task_test.go ├── sprint_8 │ ├── final │ │ ├── A │ │ │ ├── README.md │ │ │ ├── task.go │ │ │ └── task_test.go │ │ └── B │ │ │ ├── README.md │ │ │ ├── task.go │ │ │ └── task_test.go │ └── tasks │ │ ├── A │ │ ├── README.md │ │ ├── task.go │ │ └── task_test.go │ │ ├── B │ │ └── README.md │ │ ├── C │ │ └── README.md │ │ ├── D │ │ ├── README.md │ │ ├── task.go │ │ └── task_test.go │ │ ├── E │ │ └── README.md │ │ ├── F │ │ ├── README.md │ │ ├── task.go │ │ └── task_test.go │ │ ├── G │ │ ├── README.md │ │ ├── task.go │ │ └── task_test.go │ │ ├── H │ │ ├── README.md │ │ ├── task.go │ │ └── task_test.go │ │ ├── I │ │ ├── README.md │ │ ├── task.go │ │ └── task_test.go │ │ ├── J │ │ └── README.md │ │ ├── K │ │ ├── README.md │ │ ├── task.go │ │ └── task_test.go │ │ └── L │ │ ├── README.md │ │ ├── task.go │ │ └── task_test.go └── sprint_interview │ ├── A │ ├── README.md │ ├── task.go │ └── task_test.go │ ├── B │ ├── README.md │ ├── task.go │ └── task_test.go │ ├── C │ ├── README.md │ ├── task.go │ └── task_test.go │ ├── D │ ├── README.md │ ├── task.go │ └── task_test.go │ ├── E │ ├── README.md │ ├── task.go │ └── task_test.go │ ├── F │ ├── README.md │ ├── task.go │ └── task_test.go │ ├── G │ ├── README.md │ ├── task.go │ └── task_test.go │ ├── H │ ├── README.md │ ├── task.go │ └── task_test.go │ ├── I │ ├── README.md │ ├── image.png │ ├── task.go │ └── task_test.go │ ├── J │ ├── README.md │ ├── task.go │ └── task_test.go │ ├── K │ ├── README.md │ ├── task.go │ └── task_test.go │ ├── L │ ├── README.md │ ├── task.go │ └── task_test.go │ ├── M │ ├── README.md │ ├── task.go │ └── task_test.go │ ├── N │ ├── README.md │ ├── task.go │ └── task_test.go │ ├── O │ ├── README.md │ ├── task.go │ └── task_test.go │ ├── P │ ├── README.md │ ├── task.go │ └── task_test.go │ ├── Q │ ├── README.md │ ├── task.go │ └── task_test.go │ ├── R │ ├── README.md │ ├── task.go │ └── task_test.go │ ├── S │ ├── README.md │ ├── task.go │ └── task_test.go │ ├── T │ ├── README.md │ ├── task.go │ └── task_test.go │ └── U │ ├── README.md │ ├── task.go │ └── task_test.go └── yandex_training_1 └── study_1 ├── A ├── README.md ├── task.go └── task_test.go └── B ├── README.md ├── task.go └── task_test.go /.github/FUNDING.yml: -------------------------------------------------------------------------------- 1 | github: [dmitryburov] -------------------------------------------------------------------------------- /.github/ISSUE_TEMPLATE/bug_report.md: -------------------------------------------------------------------------------- 1 | --- 2 | name: Bug report 3 | about: Create a report to help us improve 4 | title: '' 5 | labels: '' 6 | assignees: '' 7 | 8 | --- 9 | 10 | **Describe the bug** 11 | A clear and concise description of what the bug is. 12 | 13 | **To Reproduce** 14 | Steps to reproduce the behavior: 15 | 1. Go to '...' 16 | 2. Click on '....' 17 | 3. Scroll down to '....' 18 | 4. See error 19 | 20 | **Expected behavior** 21 | A clear and concise description of what you expected to happen. 22 | 23 | **Screenshots** 24 | If applicable, add screenshots to help explain your problem. 25 | 26 | **Desktop (please complete the following information):** 27 | - OS: [e.g. iOS] 28 | - Browser [e.g. chrome, safari] 29 | - Version [e.g. 22] 30 | 31 | **Smartphone (please complete the following information):** 32 | - Device: [e.g. iPhone6] 33 | - OS: [e.g. iOS8.1] 34 | - Browser [e.g. stock browser, safari] 35 | - Version [e.g. 22] 36 | 37 | **Additional context** 38 | Add any other context about the problem here. 39 | -------------------------------------------------------------------------------- /.github/ISSUE_TEMPLATE/feature_request.md: -------------------------------------------------------------------------------- 1 | --- 2 | name: Feature request 3 | about: Suggest an idea for this project 4 | title: '' 5 | labels: '' 6 | assignees: '' 7 | 8 | --- 9 | 10 | **Is your feature request related to a problem? Please describe.** 11 | A clear and concise description of what the problem is. Ex. I'm always frustrated when [...] 12 | 13 | **Describe the solution you'd like** 14 | A clear and concise description of what you want to happen. 15 | 16 | **Describe alternatives you've considered** 17 | A clear and concise description of any alternative solutions or features you've considered. 18 | 19 | **Additional context** 20 | Add any other context or screenshots about the feature request here. 21 | -------------------------------------------------------------------------------- /.github/dependabot.yml: -------------------------------------------------------------------------------- 1 | version: 2 2 | updates: 3 | - package-ecosystem: "gomod" 4 | directory: "/" 5 | schedule: 6 | interval: "daily" 7 | -------------------------------------------------------------------------------- /.github/semantic.yml: -------------------------------------------------------------------------------- 1 | # Always validate the PR title AND all the commits 2 | titleAndCommits: true 3 | # Allows use of Merge commits (eg on github: "Merge branch 'master' into feature/ride-unicorns") 4 | # this is only relevant when using commitsOnly: true (or titleAndCommits: true) 5 | allowMergeCommits: true -------------------------------------------------------------------------------- /.github/workflows/tests.yml: -------------------------------------------------------------------------------- 1 | name: Test solutions 2 | 3 | on: 4 | push: 5 | branches: 6 | - master 7 | 8 | jobs: 9 | lint: 10 | name: lint check 11 | runs-on: ubuntu-latest 12 | steps: 13 | - uses: actions/checkout@v4 14 | 15 | - uses: actions/setup-go@v5 16 | with: 17 | go-version: 1.21 18 | cache: false 19 | 20 | - name: golangci-lint 21 | uses: golangci/golangci-lint-action@v4 22 | with: 23 | version: latest 24 | 25 | tests: 26 | name: test check 27 | environment: tests 28 | runs-on: ubuntu-latest 29 | steps: 30 | - name: Install Go 31 | uses: actions/setup-go@v5 32 | with: 33 | go-version: 1.21 34 | 35 | - run: go version 36 | 37 | - name: Checkout code 38 | uses: actions/checkout@v4 39 | 40 | - name: Install dependencies 41 | run: go mod download -x 42 | 43 | - name: Run Tests 44 | run: make test 45 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | ### Go template 2 | # Binaries for programs and plugins 3 | *.exe 4 | *.exe~ 5 | *.dll 6 | *.so 7 | *.dylib 8 | 9 | # Test binary, built with `go test -c` 10 | *.test 11 | 12 | # Output of the go coverage tool, specifically when used with LiteIDE 13 | *.out 14 | 15 | # Dependency directories (remove the comment below to include it) 16 | .bin/ 17 | .idea/ 18 | -------------------------------------------------------------------------------- /CONTRIBUTING.md: -------------------------------------------------------------------------------- 1 | # Contributing 2 | 3 | Thank you for taking the time to contribute. Please read the [CODE of CONDUCT](CODE_OF_CONDUCT.md). 4 | As a contributor, here are the guidelines we would like you to follow: 5 | 6 | - [Commit Message Guidelines](#commit) 7 | 8 | --- 9 | 10 | ## Commit Message Guidelines 😎 11 | 12 | In order to make git commit messages **easier to read** and faster to reason about, we follow some guidelines on most commits to keep the **format predictable**. Check [Conventional Commits specification](https://conventionalcommits.org) for more information about our guidelines. 13 | -------------------------------------------------------------------------------- /Makefile: -------------------------------------------------------------------------------- 1 | #!make 2 | TAG=$(shell git describe --tags |cut -d- -f1) 3 | COMMIT=$(shell git rev-parse --short HEAD) 4 | LDFLAGS=-a -installsuffix cgo 5 | 6 | .SILENT: 7 | .DEFAULT_GOAL := help 8 | 9 | help: ## Show this help 10 | @echo "Makefile available targets:" 11 | @grep -h -E '^[a-zA-Z_-].+:.*?## .*$$' $(MAKEFILE_LIST) | awk 'BEGIN {FS = ":.*?## "}; {printf " * \033[36m%-15s\033[0m %s\n", $$1, $$2}' 12 | 13 | test: ## Run tests 14 | go test --short -coverprofile=cover.out -v ./... 15 | make test.coverage 16 | 17 | test.coverage: 18 | go tool cover -func=cover.out 19 | 20 | release: ## Git tag create and push 21 | git tag -s -a v${tag} -m 'chore(release): v$(tag) [skip ci]' 22 | git push origin v${tag} 23 | 24 | release.revert: ## Revert git release tag 25 | git tag -d v${tag} 26 | git push --delete origin v${tag} 27 | 28 | lint: ## Check code (used golangci-lint) 29 | GO111MODULE=on golangci-lint run 30 | 31 | clean: ## Clean build directory 32 | rm -rf ./.bin -------------------------------------------------------------------------------- /SECURITY.md: -------------------------------------------------------------------------------- 1 | # Security Policy 2 | 3 | ## Supported Versions 4 | 5 | Use this section to tell people about which versions of your project are 6 | currently being supported with security updates. 7 | 8 | | Version | Supported | 9 | | ------- | ------------------ | 10 | | 1.16.x | :white_check_mark: | 11 | | > 1.16 | :white_check_mark: | 12 | | < 1.16 | :x: | 13 | 14 | ## Reporting a Vulnerability 15 | 16 | Use this section to tell people how to report a vulnerability. 17 | 18 | Tell them where to go, how often they can expect to get an update on a 19 | reported vulnerability, what to expect if the vulnerability is accepted or 20 | declined, etc. 21 | -------------------------------------------------------------------------------- /codewars/mergesort_merge_function/README.md: -------------------------------------------------------------------------------- 1 | # MergeSort "merge" function 2 | 3 | See more about problem: [Click](https://www.codewars.com/kata/52336a4436e0b095d8000093) -------------------------------------------------------------------------------- /codewars/mergesort_merge_function/solution.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func mergeSorted(arr1, arr2 []int) []int { 4 | var result = make([]int, len(arr1)+len(arr2)) 5 | 6 | i, j, k := 0, 0, 0 7 | for i < len(arr1) && j < len(arr2) { 8 | if arr1[i] <= arr2[j] { 9 | result[k] = arr1[i] 10 | i++ 11 | } else { 12 | result[k] = arr2[j] 13 | j++ 14 | } 15 | k++ 16 | } 17 | 18 | for i < len(arr1) { 19 | result[k] = arr1[i] 20 | i++ 21 | k++ 22 | } 23 | 24 | for j < len(arr2) { 25 | result[k] = arr2[j] 26 | j++ 27 | k++ 28 | } 29 | 30 | return result 31 | } 32 | -------------------------------------------------------------------------------- /codewars/mergesort_merge_function/solution_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "reflect" 6 | "testing" 7 | ) 8 | 9 | type TestItemInput struct { 10 | arr1, arr2 []int 11 | } 12 | 13 | type TestItem struct { 14 | input TestItemInput 15 | output []int 16 | } 17 | 18 | func TestTask(t *testing.T) { 19 | for i, v := range generateTasks() { 20 | t.Run(fmt.Sprintf("Test %d", i+1), func(t *testing.T) { 21 | res := mergeSorted(v.input.arr1, v.input.arr2) 22 | if !reflect.DeepEqual(res, v.output) { 23 | t.Errorf("Wrong test.\nOutput: \n%v \nExpected: \n%v", res, v.output) 24 | } 25 | }) 26 | } 27 | } 28 | func generateTasks() []TestItem { 29 | return []TestItem{ 30 | { 31 | input: TestItemInput{ 32 | arr1: []int{1, 2, 3, 4}, 33 | arr2: []int{5, 6, 7, 8}, 34 | }, 35 | output: []int{1, 2, 3, 4, 5, 6, 7, 8}, 36 | }, 37 | { 38 | input: TestItemInput{ 39 | arr1: []int{2, 4, 6}, 40 | arr2: []int{1, 3, 5}, 41 | }, 42 | output: []int{1, 2, 3, 4, 5, 6}, 43 | }, 44 | { 45 | input: TestItemInput{ 46 | arr1: []int{1, 1, 1}, 47 | arr2: []int{2, 2, 2}, 48 | }, 49 | output: []int{1, 1, 1, 2, 2, 2}, 50 | }, 51 | { 52 | input: TestItemInput{ 53 | arr1: []int{1}, 54 | arr2: []int{1}, 55 | }, 56 | output: []int{1, 1}, 57 | }, 58 | } 59 | } 60 | -------------------------------------------------------------------------------- /codewars/weird_string_case/README.md: -------------------------------------------------------------------------------- 1 | # WeIrD StRiNg CaSe 2 | 3 | See more about problem: [Click](https://www.codewars.com/kata/52b757663a95b11b3d00062d/) -------------------------------------------------------------------------------- /codewars/weird_string_case/solution.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "strings" 5 | "unicode" 6 | ) 7 | 8 | func toWeirdCase(str string) string { 9 | var result strings.Builder 10 | 11 | i := 1 12 | for _, ch := range str { 13 | if unicode.IsSpace(ch) || !unicode.IsLetter(ch) { 14 | i = 1 15 | result.WriteRune(ch) 16 | } else { 17 | if i%2 == 0 { 18 | result.WriteByte(byte(unicode.ToLower(ch))) 19 | } else { 20 | result.WriteByte(byte(unicode.ToUpper(ch))) 21 | } 22 | i++ 23 | } 24 | } 25 | 26 | return result.String() 27 | } 28 | -------------------------------------------------------------------------------- /codewars/weird_string_case/solution_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "reflect" 6 | "testing" 7 | ) 8 | 9 | type TestItem struct { 10 | input string 11 | output string 12 | } 13 | 14 | func TestTask(t *testing.T) { 15 | for i, v := range generateTasks() { 16 | t.Run(fmt.Sprintf("Test %d", i+1), func(t *testing.T) { 17 | res := toWeirdCase(v.input) 18 | if !reflect.DeepEqual(res, v.output) { 19 | t.Errorf("Wrong test.\nOutput: \n%v \nExpected: \n%v", res, v.output) 20 | } 21 | }) 22 | } 23 | } 24 | 25 | func generateTasks() []TestItem { 26 | return []TestItem{ 27 | { 28 | input: "abc def", 29 | output: "AbC DeF", 30 | }, 31 | { 32 | input: "ABC", 33 | output: "AbC", 34 | }, 35 | { 36 | input: "This is a test Looks like you passed", 37 | output: "ThIs Is A TeSt LoOkS LiKe YoU PaSsEd", 38 | }, 39 | { 40 | input: "Yo", 41 | output: "Yo", 42 | }, 43 | } 44 | } 45 | -------------------------------------------------------------------------------- /docs/hero-image.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dmitryburov/algorithm-practice/1501896081a17ead0f3e5571f9f13cabaf889142/docs/hero-image.jpg -------------------------------------------------------------------------------- /go.mod: -------------------------------------------------------------------------------- 1 | module github.com/dmitryburov/algo-yandex-practicum 2 | 3 | go 1.21 4 | -------------------------------------------------------------------------------- /leetcode/1/README.md: -------------------------------------------------------------------------------- 1 | # 1. Two Sum 2 | 3 | Подробнее о задаче: [Тыц](https://leetcode.com/problems/two-sum/) -------------------------------------------------------------------------------- /leetcode/1/solution.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func twoSum(nums []int, target int) []int { 4 | hMap := make(map[int]int) 5 | 6 | for i := 0; i < len(nums); i++ { 7 | if j, ok := hMap[target-nums[i]]; ok { 8 | return []int{j, i} 9 | } 10 | hMap[nums[i]] = i 11 | } 12 | 13 | return nil 14 | } 15 | -------------------------------------------------------------------------------- /leetcode/1/solution_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "reflect" 6 | "testing" 7 | ) 8 | 9 | type TestItemInput struct { 10 | nums []int 11 | target int 12 | } 13 | type TestItem struct { 14 | input TestItemInput 15 | output []int 16 | } 17 | 18 | func TestTask(t *testing.T) { 19 | for i, v := range generateTasks() { 20 | t.Run(fmt.Sprintf("Test %d", i+1), func(t *testing.T) { 21 | res := twoSum(v.input.nums, v.input.target) 22 | if !reflect.DeepEqual(res, v.output) { 23 | t.Errorf("Wrong test.\nOutput: \n%v \nExpected: \n%v", res, v.output) 24 | } 25 | }) 26 | } 27 | } 28 | 29 | func generateTasks() []TestItem { 30 | return []TestItem{ 31 | { 32 | input: TestItemInput{nums: []int{2, 7, 11, 15}, target: 9}, 33 | output: []int{0, 1}, 34 | }, 35 | { 36 | input: TestItemInput{nums: []int{3, 2, 4}, target: 6}, 37 | output: []int{1, 2}, 38 | }, 39 | { 40 | input: TestItemInput{nums: []int{3, 3}, target: 6}, 41 | output: []int{0, 1}, 42 | }, 43 | } 44 | } 45 | -------------------------------------------------------------------------------- /leetcode/15/README.md: -------------------------------------------------------------------------------- 1 | # 15. 3Sum 2 | 3 | Подробнее о задаче: [Тыц](https://leetcode.com/problems/3sum/description/) -------------------------------------------------------------------------------- /leetcode/15/solution.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "sort" 5 | ) 6 | 7 | func threeSum(nums []int) [][]int { 8 | var res [][]int 9 | 10 | sort.Ints(nums) 11 | 12 | for i := 0; i < len(nums)-2; i++ { 13 | if i == 0 || (i > 0 && nums[i] != nums[i-1]) { 14 | low := i + 1 15 | high := len(nums) - 1 16 | sum := 0 - nums[i] 17 | 18 | for low < high { 19 | if (nums[low] + nums[high]) == sum { 20 | res = append(res, []int{nums[i], nums[low], nums[high]}) 21 | for low < high && nums[low] == nums[low+1] { 22 | low++ 23 | } 24 | for low < high && nums[high] == nums[high-1] { 25 | high-- 26 | } 27 | low++ 28 | high-- 29 | } else if nums[low]+nums[high] > sum { 30 | high-- 31 | } else { 32 | low++ 33 | } 34 | } 35 | } 36 | } 37 | 38 | return res 39 | } 40 | -------------------------------------------------------------------------------- /leetcode/15/solution_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "reflect" 6 | "testing" 7 | ) 8 | 9 | type TestItemInput struct { 10 | nums []int 11 | } 12 | type TestItem struct { 13 | input TestItemInput 14 | output [][]int 15 | } 16 | 17 | func TestTask(t *testing.T) { 18 | for i, v := range generateTasks() { 19 | t.Run(fmt.Sprintf("Test %d", i+1), func(t *testing.T) { 20 | res := threeSum(v.input.nums) 21 | if !reflect.DeepEqual(res, v.output) { 22 | t.Errorf("Wrong test.\nOutput: \n%v \nExpected: \n%v", res, v.output) 23 | } 24 | }) 25 | } 26 | } 27 | 28 | func generateTasks() []TestItem { 29 | return []TestItem{ 30 | { 31 | input: TestItemInput{nums: []int{-1, 0, 1, 2, -1, -4}}, 32 | output: [][]int{{-1, -1, 2}, {-1, 0, 1}}, 33 | }, 34 | { 35 | input: TestItemInput{nums: []int{0, 1, 1}}, 36 | output: nil, 37 | }, 38 | { 39 | input: TestItemInput{nums: []int{0, 0, 0}}, 40 | output: [][]int{{0, 0, 0}}, 41 | }, 42 | } 43 | } 44 | -------------------------------------------------------------------------------- /leetcode/155/README.md: -------------------------------------------------------------------------------- 1 | # 155. Min Stack 2 | 3 | Подробнее о задаче: [Тыц](https://leetcode.com/problems/min-stack/) -------------------------------------------------------------------------------- /leetcode/155/solution.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | type MinStack struct { 4 | stack, min []int 5 | } 6 | 7 | func Constructor() MinStack { 8 | return MinStack{} 9 | } 10 | 11 | func (this *MinStack) Push(val int) { 12 | this.stack = append(this.stack, val) 13 | 14 | if len(this.min) > 0 { 15 | min := this.GetMin() 16 | if min < val { 17 | val = min 18 | } 19 | } 20 | 21 | this.min = append(this.min, val) 22 | } 23 | 24 | func (this *MinStack) Pop() { 25 | this.stack = this.stack[:len(this.stack)-1] 26 | this.min = this.min[:len(this.min)-1] 27 | } 28 | 29 | func (this *MinStack) Top() int { 30 | return this.stack[len(this.stack)-1] 31 | } 32 | 33 | func (this *MinStack) GetMin() int { 34 | return this.min[len(this.min)-1] 35 | } 36 | 37 | func (this *MinStack) Empty() bool { 38 | return len(this.stack) > 0 39 | } 40 | -------------------------------------------------------------------------------- /leetcode/167/README.md: -------------------------------------------------------------------------------- 1 | # 167. Two Sum II - Input Array Is Sorted 2 | 3 | See more about problem: [Click](https://leetcode.com/problems/two-sum-ii-input-array-is-sorted/) -------------------------------------------------------------------------------- /leetcode/167/solution.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func twoSum(numbers []int, target int) []int { 4 | hMap := make(map[int]int) 5 | 6 | for i := 0; i < len(numbers); i++ { 7 | if j, ok := hMap[target-numbers[i]]; ok { 8 | return []int{j + 1, i + 1} 9 | } 10 | hMap[numbers[i]] = i 11 | } 12 | 13 | return nil 14 | } 15 | -------------------------------------------------------------------------------- /leetcode/167/solution_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "reflect" 6 | "testing" 7 | ) 8 | 9 | type TestItemInput struct { 10 | arr []int 11 | target int 12 | } 13 | 14 | type TestItem struct { 15 | input TestItemInput 16 | output []int 17 | } 18 | 19 | func TestTask(t *testing.T) { 20 | for i, v := range generateTasks() { 21 | t.Run(fmt.Sprintf("Test %d", i+1), func(t *testing.T) { 22 | res := twoSum(v.input.arr, v.input.target) 23 | if !reflect.DeepEqual(res, v.output) { 24 | t.Errorf("Wrong test.\nOutput: \n%v \nExpected: \n%v", res, v.output) 25 | } 26 | }) 27 | } 28 | } 29 | 30 | func generateTasks() []TestItem { 31 | return []TestItem{ 32 | { 33 | input: TestItemInput{ 34 | arr: []int{2, 7, 11, 15}, 35 | target: 9, 36 | }, 37 | output: []int{1, 2}, 38 | }, 39 | { 40 | input: TestItemInput{ 41 | arr: []int{2, 3, 4}, 42 | target: 6, 43 | }, 44 | output: []int{1, 3}, 45 | }, 46 | { 47 | input: TestItemInput{ 48 | arr: []int{-1, 0}, 49 | target: -1, 50 | }, 51 | output: []int{1, 2}, 52 | }, 53 | } 54 | } 55 | -------------------------------------------------------------------------------- /leetcode/19/README.md: -------------------------------------------------------------------------------- 1 | # 19. Remove Nth Node From End of List 2 | 3 | Подробнее о задаче: [Тыц](https://leetcode.com/problems/remove-nth-node-from-end-of-list/) -------------------------------------------------------------------------------- /leetcode/19/solution.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | type ListNode struct { 4 | Val int 5 | Next *ListNode 6 | } 7 | 8 | func removeNthFromEnd(head *ListNode, n int) *ListNode { 9 | left, right := head, head 10 | 11 | for i := 1; i <= n && right != nil; i++ { 12 | right = right.Next 13 | } 14 | if right == nil { 15 | return head.Next 16 | } 17 | 18 | for right != nil && right.Next != nil { 19 | left = left.Next 20 | right = right.Next 21 | } 22 | 23 | left.Next = left.Next.Next 24 | 25 | return head 26 | } 27 | -------------------------------------------------------------------------------- /leetcode/328/README.md: -------------------------------------------------------------------------------- 1 | # 328. Odd Even Linked List 2 | 3 | Подробнее о задаче: [Тыц](https://leetcode.com/problems/odd-even-linked-list/) -------------------------------------------------------------------------------- /leetcode/328/solution.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | type ListNode struct { 4 | Val int 5 | Next *ListNode 6 | } 7 | 8 | func oddEvenList(head *ListNode) *ListNode { 9 | if head == nil { 10 | return nil 11 | } 12 | if head.Next == nil { 13 | return head 14 | } 15 | 16 | var ( 17 | current = head 18 | prev = head.Next 19 | next = prev 20 | counter int 21 | ) 22 | 23 | for next.Next != nil { 24 | counter++ 25 | 26 | current.Next = next.Next 27 | current = next 28 | next = current.Next 29 | } 30 | 31 | if counter%2 == 0 { 32 | current.Next = prev 33 | } else { 34 | current.Next = nil 35 | next.Next = prev 36 | } 37 | 38 | return head 39 | } 40 | -------------------------------------------------------------------------------- /leetcode/33/README.md: -------------------------------------------------------------------------------- 1 | # 33. Search in Rotated Sorted Array 2 | 3 | Подробнее о задаче: [Тыц](https://leetcode.com/problems/search-in-rotated-sorted-array/) -------------------------------------------------------------------------------- /leetcode/33/solution.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func search(nums []int, target int) int { 4 | n := len(nums) 5 | left, right := 0, n-1 6 | 7 | for left < right { 8 | mid := left + (right-left)/2 9 | if nums[mid] > nums[right] { 10 | left = mid + 1 11 | } else { 12 | right = mid 13 | } 14 | } 15 | 16 | pivot := left 17 | left, right = pivot, pivot-1+n 18 | 19 | for left <= right { 20 | mid := left + (right-left)/2 21 | midVal := nums[mid%n] 22 | 23 | if midVal > target { 24 | right = mid - 1 25 | } else if midVal < target { 26 | left = mid + 1 27 | } else { 28 | return mid % n 29 | } 30 | } 31 | 32 | return -1 33 | } 34 | -------------------------------------------------------------------------------- /leetcode/33/solution_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "reflect" 6 | "testing" 7 | ) 8 | 9 | type TestItemInput struct { 10 | nums []int 11 | target int 12 | } 13 | type TestItem struct { 14 | input TestItemInput 15 | output int 16 | } 17 | 18 | func TestTask(t *testing.T) { 19 | for i, v := range generateTasks() { 20 | t.Run(fmt.Sprintf("Test %d", i+1), func(t *testing.T) { 21 | res := search(v.input.nums, v.input.target) 22 | if !reflect.DeepEqual(res, v.output) { 23 | t.Errorf("Wrong test.\nOutput: \n%v \nExpected: \n%v", res, v.output) 24 | } 25 | }) 26 | } 27 | } 28 | 29 | func generateTasks() []TestItem { 30 | return []TestItem{ 31 | { 32 | input: TestItemInput{nums: []int{4, 5, 6, 7, 0, 1, 2}, target: 0}, 33 | output: 4, 34 | }, 35 | { 36 | input: TestItemInput{nums: []int{4, 5, 6, 7, 0, 1, 2}, target: 3}, 37 | output: -1, 38 | }, 39 | { 40 | input: TestItemInput{nums: []int{1}, target: 0}, 41 | output: -1, 42 | }, 43 | } 44 | } 45 | -------------------------------------------------------------------------------- /leetcode/347/README.md: -------------------------------------------------------------------------------- 1 | # 347. Top K Frequent Elements 2 | 3 | Подробнее о задаче: [Тыц](https://leetcode.com/problems/top-k-frequent-elements/) -------------------------------------------------------------------------------- /leetcode/347/solution.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func topKFrequent(nums []int, k int) []int { 4 | var result []int 5 | 6 | var numMap = make(map[int]int) 7 | for _, val := range nums { 8 | numMap[val]++ 9 | } 10 | 11 | freqMap := make(map[int][]int) 12 | for key, freq := range numMap { 13 | freqMap[freq] = append(freqMap[freq], key) 14 | } 15 | 16 | for i := len(nums); len(result) != k; i-- { 17 | for _, n := range freqMap[i] { 18 | if len(result) != k { 19 | result = append(result, n) 20 | } 21 | } 22 | } 23 | 24 | return result 25 | } 26 | -------------------------------------------------------------------------------- /leetcode/347/solution_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "reflect" 6 | "testing" 7 | ) 8 | 9 | type TestItemInput struct { 10 | arr []int 11 | k int 12 | } 13 | 14 | type TestItem struct { 15 | input TestItemInput 16 | output []int 17 | } 18 | 19 | func TestTask(t *testing.T) { 20 | for i, v := range generateTasks() { 21 | t.Run(fmt.Sprintf("Test %d", i+1), func(t *testing.T) { 22 | res := topKFrequent(v.input.arr, v.input.k) 23 | if !reflect.DeepEqual(res, v.output) { 24 | t.Errorf("Wrong test.\nOutput: \n%v \nExpected: \n%v", res, v.output) 25 | } 26 | }) 27 | } 28 | } 29 | 30 | func generateTasks() []TestItem { 31 | return []TestItem{ 32 | { 33 | input: TestItemInput{ 34 | arr: []int{1, 1, 1, 2, 2, 3}, 35 | k: 2, 36 | }, 37 | output: []int{1, 2}, 38 | }, 39 | { 40 | input: TestItemInput{ 41 | arr: []int{1}, 42 | k: 1, 43 | }, 44 | output: []int{1}, 45 | }, 46 | { 47 | input: TestItemInput{ 48 | arr: []int{1, 1, 2, 4, 1, 3, 3, 4, 10}, 49 | k: 3, 50 | }, 51 | output: []int{1, 4, 3}, 52 | }, 53 | } 54 | } 55 | -------------------------------------------------------------------------------- /leetcode/56/README.md: -------------------------------------------------------------------------------- 1 | # 56. Merge Intervals 2 | 3 | Подробнее о задаче: [Тыц](https://leetcode.com/problems/merge-intervals/) -------------------------------------------------------------------------------- /leetcode/56/solution.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "sort" 5 | ) 6 | 7 | func merge(intervals [][]int) [][]int { 8 | sort.Slice(intervals, func(i, j int) bool { 9 | return intervals[i][0] < intervals[j][0] 10 | }) 11 | 12 | result := make([][]int, 0) 13 | 14 | for _, interval := range intervals { 15 | if len(result) == 0 || result[len(result)-1][1] < interval[0] { 16 | result = append(result, interval) 17 | } else { 18 | max := result[len(result)-1][1] 19 | if result[len(result)-1][1] < interval[1] { 20 | max = interval[1] 21 | } 22 | result[len(result)-1][1] = max 23 | } 24 | } 25 | 26 | return result 27 | } 28 | -------------------------------------------------------------------------------- /leetcode/56/solution_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "reflect" 6 | "testing" 7 | ) 8 | 9 | type TestItemInput struct { 10 | nums [][]int 11 | } 12 | type TestItem struct { 13 | input TestItemInput 14 | output [][]int 15 | } 16 | 17 | func TestTask(t *testing.T) { 18 | for i, v := range generateTasks() { 19 | t.Run(fmt.Sprintf("Test %d", i+1), func(t *testing.T) { 20 | res := merge(v.input.nums) 21 | if !reflect.DeepEqual(res, v.output) { 22 | t.Errorf("Wrong test.\nOutput: \n%v \nExpected: \n%v", res, v.output) 23 | } 24 | }) 25 | } 26 | } 27 | 28 | func generateTasks() []TestItem { 29 | return []TestItem{ 30 | { 31 | input: TestItemInput{nums: [][]int{{1, 3}, {2, 6}, {8, 10}, {15, 18}}}, 32 | output: [][]int{{1, 6}, {8, 10}, {15, 18}}, 33 | }, 34 | { 35 | input: TestItemInput{nums: [][]int{{1, 4}, {4, 5}}}, 36 | output: [][]int{{1, 5}}, 37 | }, 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /leetcode/66/README.md: -------------------------------------------------------------------------------- 1 | # 15. 3Sum 2 | 3 | Подробнее о задаче: [Тыц](https://leetcode.com/problems/3sum/description/) -------------------------------------------------------------------------------- /leetcode/66/solution.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func plusOne(digits []int) []int { 4 | n := len(digits) 5 | 6 | for i := n - 1; i >= 0; i-- { 7 | if digits[i] < 9 { 8 | digits[i]++ 9 | return digits 10 | } 11 | 12 | digits[i] = 0 13 | } 14 | 15 | digits = append([]int{1}, digits...) 16 | 17 | return digits 18 | } 19 | -------------------------------------------------------------------------------- /leetcode/66/solution_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "reflect" 6 | "testing" 7 | ) 8 | 9 | type TestItemInput struct { 10 | nums []int 11 | } 12 | type TestItem struct { 13 | input TestItemInput 14 | output []int 15 | } 16 | 17 | func TestTask(t *testing.T) { 18 | for i, v := range generateTasks() { 19 | t.Run(fmt.Sprintf("Test %d", i+1), func(t *testing.T) { 20 | res := plusOne(v.input.nums) 21 | if !reflect.DeepEqual(res, v.output) { 22 | t.Errorf("Wrong test.\nOutput: \n%v \nExpected: \n%v", res, v.output) 23 | } 24 | }) 25 | } 26 | } 27 | 28 | func generateTasks() []TestItem { 29 | return []TestItem{ 30 | { 31 | input: TestItemInput{nums: []int{1, 2, 3}}, 32 | output: []int{1, 2, 4}, 33 | }, 34 | { 35 | input: TestItemInput{nums: []int{4, 3, 2, 1}}, 36 | output: []int{4, 3, 2, 2}, 37 | }, 38 | { 39 | input: TestItemInput{nums: []int{9}}, 40 | output: []int{1, 0}, 41 | }, 42 | } 43 | } 44 | -------------------------------------------------------------------------------- /leetcode/88/README.md: -------------------------------------------------------------------------------- 1 | # 88. Merge Sorted Array 2 | 3 | See more about problem: [Click](https://leetcode.com/problems/merge-sorted-array/) -------------------------------------------------------------------------------- /leetcode/88/solution.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func merge(nums1 []int, m int, nums2 []int, n int) { 4 | i, j, k := m-1, n-1, (m+n)-1 5 | 6 | for ; j >= 0; k-- { 7 | if i >= 0 && nums1[i] > nums2[j] { 8 | nums1[k] = nums1[i] 9 | i-- 10 | } else { 11 | nums1[k] = nums2[j] 12 | j-- 13 | } 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /leetcode/88/solution_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "reflect" 6 | "testing" 7 | ) 8 | 9 | type TestItemInput struct { 10 | num1, num2 []int 11 | n1, n2 int 12 | } 13 | 14 | type TestItem struct { 15 | input TestItemInput 16 | output []int 17 | } 18 | 19 | func TestTask(t *testing.T) { 20 | for i, v := range generateTasks() { 21 | t.Run(fmt.Sprintf("Test %d", i+1), func(t *testing.T) { 22 | merge(v.input.num1, v.input.n1, v.input.num2, v.input.n2) 23 | if !reflect.DeepEqual(v.input.num1, v.output) { 24 | t.Errorf("Wrong test.\nOutput: \n%v \nExpected: \n%v", v.input.num1, v.output) 25 | } 26 | }) 27 | } 28 | } 29 | 30 | func generateTasks() []TestItem { 31 | return []TestItem{ 32 | { 33 | input: TestItemInput{ 34 | num1: []int{1, 2, 3, 0, 0, 0}, 35 | n1: 3, 36 | num2: []int{2, 5, 6}, 37 | n2: 3, 38 | }, 39 | output: []int{1, 2, 2, 3, 5, 6}, 40 | }, 41 | { 42 | input: TestItemInput{ 43 | num1: []int{1}, 44 | n1: 1, 45 | num2: []int{0}, 46 | n2: 0, 47 | }, 48 | output: []int{1}, 49 | }, 50 | { 51 | input: TestItemInput{ 52 | num1: []int{0}, 53 | n1: 0, 54 | num2: []int{1}, 55 | n2: 1, 56 | }, 57 | output: []int{1}, 58 | }, 59 | } 60 | } 61 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_1/final/A/input.txt: -------------------------------------------------------------------------------- 1 | 20 2 | 10 13 31 35 39 0 0 59 0 66 68 73 74 0 0 0 87 89 96 99 3 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_1/final/B/input.txt: -------------------------------------------------------------------------------- 1 | 4 2 | 1111 3 | 9999 4 | 1111 5 | 9911 6 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_1/tasks/A/README.md: -------------------------------------------------------------------------------- 1 | # A. Значения функции 2 | 3 | Вася делает тест по математике: вычисляет значение функций в различных точках. Стоит отличная погода, и друзья зовут Васю гулять. Но мальчик решил сначала закончить тест и только после этого идти к друзьям. 4 | К сожалению, Вася пока не умеет программировать. Зато вы умеете. 5 | 6 | Помогите Васе написать код функции, вычисляющей y = ax2 + bx + c. Напишите программу, которая будет по коэффициентам a, b, c и числу x выводить значение функции в точке x. 7 | 8 | ## Формат ввода 9 | 10 | На вход через пробел подаются числа a, x, b, c. В конце ввода находится перенос строки. 11 | 12 | ## Формат вывода 13 | 14 | Выведите одно число — значение функции в точке x. 15 | 16 | 17 | ### Пример 1 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 |
ВводВывод
-8 -5 -2 7-183
33 | 34 | ### Пример 2 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 |
ВводВывод
8 2 9 -1040
50 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_1/tasks/A/input.txt: -------------------------------------------------------------------------------- 1 | -8 -5 -2 7 2 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_1/tasks/A/task.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bufio" 5 | "os" 6 | "strconv" 7 | "strings" 8 | ) 9 | 10 | func main() { 11 | var a, b, c, x int 12 | 13 | reader := bufio.NewReader(os.Stdin) 14 | scanner := bufio.NewScanner(reader) 15 | writer := bufio.NewWriter(os.Stdout) 16 | 17 | scanner.Scan() 18 | line := scanner.Text() 19 | 20 | values := strings.Split(line, " ") 21 | 22 | a, _ = strconv.Atoi(values[0]) 23 | x, _ = strconv.Atoi(values[1]) 24 | b, _ = strconv.Atoi(values[2]) 25 | c, _ = strconv.Atoi(values[3]) 26 | 27 | result := a*(x*x) + b*x + c 28 | 29 | _, _ = writer.WriteString(strconv.Itoa(result)) 30 | _, _ = writer.WriteString("\n") 31 | _ = writer.Flush() 32 | } 33 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_1/tasks/B/input.txt: -------------------------------------------------------------------------------- 1 | 1 2 -3 2 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_1/tasks/B/task.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bufio" 5 | "os" 6 | "strconv" 7 | "strings" 8 | ) 9 | 10 | func main() { 11 | 12 | reader := bufio.NewReader(os.Stdin) 13 | scanner := bufio.NewScanner(reader) 14 | writer := bufio.NewWriter(os.Stdout) 15 | 16 | scanner.Scan() 17 | line := scanner.Text() 18 | 19 | var result = "WIN" 20 | var values = strings.Split(line, " ") 21 | var last int 22 | 23 | for i := 0; i < len(values); i++ { 24 | num, _ := strconv.Atoi(values[i]) 25 | if num%2 == 0 { 26 | if last == 1 { 27 | result = "FAIL" 28 | break 29 | } 30 | last = 2 31 | } else { 32 | if last == 2 { 33 | result = "FAIL" 34 | break 35 | } 36 | last = 1 37 | } 38 | } 39 | 40 | _, _ = writer.WriteString(result) 41 | _, _ = writer.WriteString("\n") 42 | _ = writer.Flush() 43 | } 44 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_1/tasks/C/input.txt: -------------------------------------------------------------------------------- 1 | 4 2 | 3 3 | 1 2 3 4 | 0 2 6 5 | 7 4 1 6 | 2 7 0 7 | 3 8 | 0 9 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_1/tasks/D/input.txt: -------------------------------------------------------------------------------- 1 | 7 2 | -1 -10 -8 0 2 0 5 3 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_1/tasks/E/input.txt: -------------------------------------------------------------------------------- 1 | 172 2 | ozmfudehppmivpkrmkvtnnzb ranigcyhpvooglyahlcjtusipmebtblqqquuweugqlkaakfdlcwzxmtcnzrcgyhsdbehy igrzfcsjbjeuhkkcbvbuvfdepdvnsiipkivrmzewqpryndfmvyhrzikzzddlqoovzmoikpwxirwn 3 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_1/tasks/E/task.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bufio" 5 | "fmt" 6 | "os" 7 | "strings" 8 | ) 9 | 10 | func main() { 11 | inp := GetInputFromFile() 12 | defer inp.Close() 13 | 14 | var find string 15 | 16 | reader := bufio.NewReader(inp) 17 | _, _ = reader.ReadString('\n') 18 | line, _ := reader.ReadString('\n') 19 | strItems := strings.Split(strings.Trim(line, ""), " ") 20 | 21 | for i := 0; i < len(strItems); i++ { 22 | trimStr := strings.TrimSpace(strItems[i]) 23 | if len(trimStr) > len(find) { 24 | find = trimStr 25 | } 26 | } 27 | 28 | fmt.Println(find) 29 | fmt.Println(len(find)) 30 | } 31 | 32 | func GetInputFromFile() *os.File { 33 | file, err := os.Open("./input.txt") 34 | if err != nil { 35 | panic(err) 36 | } 37 | 38 | return file 39 | } 40 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_1/tasks/F/README.md: -------------------------------------------------------------------------------- 1 | # F. Палиндром 2 | 3 | Помогите Васе понять, будет ли фраза палиндромом. 4 | Учитываются только буквы и цифры, заглавные и строчные буквы считаются одинаковыми. 5 | 6 | Решение должно работать за O(N), где N — длина строки на входе. 7 | 8 | ## Формат ввода 9 | 10 | В единственной строке записана фраза или слово. Буквы могут быть только латинские. Длина текста не превосходит 20000 символов. 11 | Фраза может состоять из строчных и прописных латинских букв, цифр, знаков препинания. 12 | 13 | ## Формат вывода 14 | 15 | Выведите «True», если фраза является палиндромом, и «False», если не является. 16 | 17 | ### Пример 1 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 31 | 34 | 35 | 36 |
ВводВывод
29 | A man, a plan, a canal: Panama
30 | 		32 | True
33 |
37 | 38 | ### Пример 2 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 52 | 55 | 56 | 57 |
ВводВывод
50 | zo
51 | 		53 | False
54 |
-------------------------------------------------------------------------------- /yandex_practicum/sprint_1/tasks/F/input.txt: -------------------------------------------------------------------------------- 1 | zoz 2 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_1/tasks/F/task.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bufio" 5 | "fmt" 6 | "os" 7 | "regexp" 8 | "strings" 9 | ) 10 | 11 | func main() { 12 | var inp = GetInputFromFile() 13 | defer inp.Close() 14 | 15 | reader := bufio.NewReader(inp) 16 | str, _ := reader.ReadString('\n') 17 | 18 | str = strings.ToLower(str) 19 | re := regexp.MustCompile("[^a-z]") 20 | str = re.ReplaceAllString(str, "") 21 | 22 | var result = "True" 23 | for i := 0; i < len(str); i++ { 24 | if str[i] != str[len(str)-(i+1)] { 25 | result = "False" 26 | break 27 | } 28 | } 29 | 30 | fmt.Println(result) 31 | } 32 | 33 | func GetInputFromFile() *os.File { 34 | file, err := os.Open("./input.txt") 35 | if err != nil { 36 | panic(err) 37 | } 38 | 39 | return file 40 | } 41 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_1/tasks/G/README.md: -------------------------------------------------------------------------------- 1 | # G. Работа из дома 2 | 3 | Вася реализовал функцию, которая переводит целое число из десятичной системы в двоичную. Но, кажется, она получилась не очень оптимальной. 4 | 5 | Попробуйте написать более эффективную программу. 6 | 7 | **Не используйте встроенные средства языка по переводу чисел в бинарное представление.** 8 | 9 | ## Формат ввода 10 | 11 | На вход подаётся целое число в диапазоне от 0 до 10000. 12 | 13 | ## Формат вывода 14 | 15 | Выведите двоичное представление этого числа. 16 | 17 | ### Пример 1 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 |
ВводВывод
5101
33 | 34 | ### Пример 2 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 |
ВводВывод
141110
50 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_1/tasks/G/task.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | ) 6 | 7 | func main() { 8 | 9 | var n int 10 | 11 | fmt.Scan(&n) 12 | fmt.Println(numToBinary(n)) 13 | } 14 | 15 | func numToBinary(n int) string { 16 | var binaryStr string 17 | 18 | for n > 0 { 19 | binaryStr = fmt.Sprintf("%d%s", n%2, binaryStr) 20 | n = n / 2 21 | } 22 | 23 | return binaryStr 24 | } 25 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_1/tasks/H/task.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | ) 6 | 7 | func main() { 8 | 9 | var one, two int 10 | 11 | fmt.Scanf("%d", &one) 12 | fmt.Scanf("%d", &two) 13 | 14 | fmt.Println("One:", one) 15 | fmt.Println("Two:", two) 16 | 17 | } 18 | 19 | func add(a, b int) int { 20 | if b == 0 { 21 | return a 22 | } 23 | sum := a ^ b 24 | carry := (a & b) << 1 25 | return add(sum, carry) 26 | } 27 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_1/tasks/I/README.md: -------------------------------------------------------------------------------- 1 | # I. Степень четырёх 2 | 3 | Вася на уроке математики изучил степени. Теперь он хочет написать программу, которая определяет, будет ли положительное целое число степенью четвёрки. 4 | 5 | Подсказка: степенью четвёрки будут все числа вида 4n, где n – целое неотрицательное число. 6 | 7 | ## Формат ввода 8 | 9 | На вход подаётся целое число в диапазоне от 1 до 10000. 10 | 11 | ## Формат вывода 12 | 13 | Выведите «True», если число является степенью четырёх, «False» –— в обратном случае. 14 | 15 | ### Пример 1 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 |
ВводВывод
15False
31 | 32 | ### Пример 2 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 |
ВводВывод
15True
-------------------------------------------------------------------------------- /yandex_practicum/sprint_1/tasks/I/task.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | ) 6 | 7 | func main() { 8 | 9 | var n int 10 | 11 | fmt.Scan(&n) 12 | 13 | if res := numToDegree(n, 4); res { 14 | fmt.Println("True") 15 | } else { 16 | fmt.Println("False") 17 | } 18 | } 19 | 20 | func numToDegree(num int, degree int) bool { 21 | for num%degree == 0 { 22 | num /= degree 23 | } 24 | 25 | return num == 1 26 | } 27 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_1/tasks/J/task.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "strings" 6 | ) 7 | 8 | func main() { 9 | var n int 10 | fmt.Scan(&n) 11 | 12 | var res []string 13 | var i = 2 14 | 15 | for i*i <= n { 16 | if n%i == 0 { 17 | n /= i 18 | res = append(res, fmt.Sprintf("%d", i)) 19 | } else { 20 | i += 1 21 | } 22 | } 23 | 24 | if n > 1 { 25 | res = append(res, fmt.Sprintf("%d", n)) 26 | } 27 | 28 | fmt.Println(strings.Join(res, " ")) 29 | } 30 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_1/tasks/L/task.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bufio" 5 | "os" 6 | "sort" 7 | "strings" 8 | ) 9 | 10 | func main() { 11 | reader := bufio.NewReader(os.Stdin) 12 | scanner := bufio.NewScanner(reader) 13 | writer := bufio.NewWriter(os.Stdout) 14 | 15 | var find string 16 | var values [][]string 17 | 18 | for i := 1; i <= 2; i++ { 19 | scanner.Scan() 20 | 21 | parse := strings.Split(scanner.Text(), "") 22 | sort.StringSlice(parse).Sort() 23 | 24 | values = append(values, parse) 25 | } 26 | 27 | for i := 0; i < len(values[1]); i++ { 28 | if i+1 > len(values[0]) { 29 | find = values[1][i] 30 | break 31 | } 32 | if values[1][i] != values[0][i] { 33 | find = values[1][i] 34 | break 35 | } 36 | } 37 | 38 | _, _ = writer.WriteString(find) 39 | _, _ = writer.WriteString("\n") 40 | _ = writer.Flush() 41 | } 42 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_2/final/A/input.txt: -------------------------------------------------------------------------------- 1 | 7 2 | 7 3 | pop_front 4 | pop_front 5 | push_front 741 6 | push_front 648 7 | pop_front 8 | pop_back 9 | pop_front 10 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_2/final/B/input.txt: -------------------------------------------------------------------------------- 1 | 4 2 * 4 / 25 * 2 - 12 / 500 2 * + 2 / -999 + 71 + -1 * 2 / 2 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_2/final/B/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "testing" 6 | ) 7 | 8 | type task struct { 9 | Input, 10 | Result string 11 | } 12 | 13 | func TestTask(t *testing.T) { 14 | 15 | var taskItems = generateTasks() 16 | 17 | for i := 0; i < len(taskItems); i++ { 18 | t.Run(fmt.Sprintf("Test %d", i+1), func(t *testing.T) { 19 | res, err := solution(taskItems[i].Input) 20 | if err != nil { 21 | t.Errorf("Ошибка выполнения: %s ", err.Error()) 22 | } else if fmt.Sprint(res) != taskItems[i].Result { 23 | t.Errorf("Неверный ответ решения!\nОтвет: %f \nВерно: %s", res, taskItems[i].Result) 24 | } 25 | }) 26 | } 27 | } 28 | 29 | // generateTasks создает задачи для теста 30 | func generateTasks() (tasks []task) { 31 | tasks = append( 32 | tasks, 33 | task{ 34 | Input: "2 1 + 3 *", 35 | Result: "9", 36 | }, 37 | task{ 38 | Input: "7 2 + 4 * 2 +", 39 | Result: "38", 40 | }, 41 | task{ 42 | Input: "4 2 * 4 / 25 * 2 - 12 / 1000 + 2 / -999 +", 43 | Result: "-497", 44 | }, 45 | task{ 46 | Input: "4 2 * 4 / 25 * 2 - 12 / 500 2 * + 2 / -999 + 71 + -1 * 2 / 1000 + 6 * 8065 -", 47 | Result: "-787", 48 | }, 49 | task{ 50 | Input: "4 2 * 4 / 25 * 2 - 12 / 500 2 * + 2 / -999 + 71 + -1 * 2 / 1000 + 6 * 8065 - 787 + 66 *", 51 | Result: "0", 52 | }, 53 | ) 54 | 55 | return 56 | } 57 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_2/tasks/A/input.txt: -------------------------------------------------------------------------------- 1 | 9 2 | 5 3 | -7 -1 0 -4 -9 4 | 5 -1 2 2 9 5 | 3 1 -8 -1 -7 6 | 9 0 8 -8 -1 7 | 2 4 5 2 8 8 | -7 10 0 -4 -8 9 | -3 10 -7 10 3 10 | 1 6 -7 -5 9 11 | -1 9 9 1 9 12 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_2/tasks/B/task.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | // ListNode 6 | // Comment it before submitting 7 | type ListNode struct { 8 | data string 9 | next *ListNode 10 | } 11 | 12 | // Solution решение 13 | func Solution(head *ListNode) { 14 | fmt.Println(head.data) 15 | if head.next != nil { 16 | Solution(head.next) 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_2/tasks/C/task.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | ) 6 | 7 | // ListNode 8 | // Comment it before submitting 9 | type ListNode struct { 10 | data string 11 | next *ListNode 12 | } 13 | 14 | // Solution решение 15 | func Solution(head *ListNode, idx int) *ListNode { 16 | if idx == 0 { 17 | head = head.next 18 | } 19 | 20 | if head != nil { 21 | fmt.Println(head.data) 22 | } 23 | 24 | if head != nil && head.next != nil { 25 | return Solution(head.next, idx-1) 26 | } 27 | return nil 28 | } 29 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_2/tasks/D/task.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // ListNode 4 | // Comment it before submitting 5 | type ListNode struct { 6 | data string 7 | next *ListNode 8 | } 9 | 10 | var idxNode = 0 11 | 12 | // Solution решение 13 | func Solution(head *ListNode, elem string) int { 14 | 15 | if elem == head.data { 16 | return idxNode 17 | } 18 | 19 | if head.next != nil { 20 | idxNode++ 21 | } else { 22 | return -1 23 | } 24 | 25 | return Solution(head.next, elem) 26 | } 27 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_2/tasks/E/task.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // ListNode 4 | // Comment it before submitting 5 | type ListNode struct { 6 | data string 7 | next *ListNode 8 | prev *ListNode 9 | } 10 | 11 | // Solution решение 12 | func Solution(head *ListNode) *ListNode { 13 | next := head.next 14 | head.prev, head.next = head.next, head.prev 15 | 16 | if next != nil { 17 | return Solution(next) 18 | } 19 | 20 | return head 21 | } 22 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_2/tasks/F/input.txt: -------------------------------------------------------------------------------- 1 | 7 2 | get_max 3 | pop 4 | pop 5 | pop 6 | push 10 7 | get_max 8 | push -9 9 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_2/tasks/G/input.txt: -------------------------------------------------------------------------------- 1 | 10 2 | get_max 3 | push -6 4 | pop 5 | pop 6 | get_max 7 | push 2 8 | get_max 9 | pop 10 | push -2 11 | push -6 12 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_2/tasks/H/input.txt: -------------------------------------------------------------------------------- 1 | {[()]} 2 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_2/tasks/H/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "testing" 6 | ) 7 | 8 | type task struct { 9 | Input, 10 | Result string 11 | } 12 | 13 | func TestTask(t *testing.T) { 14 | 15 | var taskItems = generateTasks() 16 | 17 | for i := 0; i < len(taskItems); i++ { 18 | t.Run(fmt.Sprintf("Test %d", i+1), func(t *testing.T) { 19 | res := solution(taskItems[i].Input) 20 | if res != taskItems[i].Result { 21 | t.Errorf("Неверный ответ решения!\nОтвет: %s \nВерно: %s", res, taskItems[i].Result) 22 | } 23 | }) 24 | } 25 | } 26 | 27 | // generateTasks создает задачи для теста 28 | func generateTasks() (tasks []task) { 29 | tasks = append( 30 | tasks, 31 | task{ 32 | Input: "{[()]}", 33 | Result: "True", 34 | }, 35 | task{ 36 | Input: "()", 37 | Result: "True", 38 | }, 39 | task{ 40 | Input: "[()}", 41 | Result: "False", 42 | }, 43 | ) 44 | 45 | return 46 | } 47 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_2/tasks/I/input.txt: -------------------------------------------------------------------------------- 1 | 17 2 | 8 3 | push -82 4 | push -25 5 | push -57 6 | push -24 7 | size 8 | push 12 9 | push 21 10 | push 62 11 | push 64 12 | push -90 13 | size 14 | pop 15 | peek 16 | push -10 17 | push 60 18 | push 67 19 | size 20 | 21 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_2/tasks/J/input.txt: -------------------------------------------------------------------------------- 1 | 10 2 | put -34 3 | put -23 4 | get 5 | size 6 | get 7 | size 8 | get 9 | get 10 | put 80 11 | size 12 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_2/tasks/K/README.md: -------------------------------------------------------------------------------- 1 | # K. Рекурсивные числа Фибоначчи 2 | 3 | У Тимофея было n(0 ≤ n ≤ 32) стажёров. Каждый стажёр хотел быть лучше своих предшественников, поэтому 4 | i-й стажёр делал столько коммитов, сколько делали два предыдущих стажёра в сумме. Два первых стажёра были менее инициативными —– они сделали по одному коммиту. 5 | 6 | Пусть Fi —– число коммитов, сделанных i-м стажёром (стажёры нумеруются с нуля). Тогда выполняется следующее: 7 | F0 = F1 = 1. Для всех i ≥ 2 выполнено Fi = Fi−1 + Fi−2. 8 | 9 | Определите, сколько кода напишет следующий стажёр –— найдите Fn. 10 | 11 | Решение должно быть реализовано рекурсивно. 12 | 13 | ## Формат ввода 14 | 15 | На вход подаётся n — целое число в диапазоне от 0 до 32. 16 | 17 | ## Формат вывода 18 | 19 | Нужно вывести Fn. 20 | 21 | ### Пример 1 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 |
ВводВывод
33
37 | 38 | ### Пример 2 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 |
ВводВывод
01
54 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_2/tasks/K/task.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | ) 6 | 7 | func main() { 8 | 9 | var n int 10 | 11 | fmt.Scan(&n) 12 | fmt.Println(solution(n)) 13 | } 14 | 15 | // solution решение задачи 16 | func solution(n int) int { 17 | if n <= 1 { 18 | return 1 19 | } 20 | 21 | return solution(n-1) + solution(n-2) 22 | } 23 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_2/tasks/K/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "testing" 6 | ) 7 | 8 | type task struct { 9 | Input, Result int 10 | } 11 | 12 | func TestTask(t *testing.T) { 13 | 14 | var taskItems = generateTasks() 15 | 16 | for i := 0; i < len(taskItems); i++ { 17 | t.Run(fmt.Sprintf("Test %d", i+1), func(t *testing.T) { 18 | res := solution(taskItems[i].Input) 19 | if res != taskItems[i].Result { 20 | t.Errorf("Неверный ответ решения!\nОтвет: %d \nВерно: %d", res, taskItems[i].Result) 21 | } 22 | }) 23 | } 24 | } 25 | 26 | // generateTasks создает задачи для теста 27 | func generateTasks() (tasks []task) { 28 | tasks = append( 29 | tasks, 30 | task{ 31 | Input: 3, 32 | Result: 3, 33 | }, 34 | task{ 35 | Input: 0, 36 | Result: 1, 37 | }, 38 | ) 39 | 40 | return 41 | } 42 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_2/tasks/L/task.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bufio" 5 | "fmt" 6 | "math" 7 | "os" 8 | "strconv" 9 | "strings" 10 | ) 11 | 12 | func main() { 13 | n, k, err := getInputData() 14 | if err != nil { 15 | showError(err) 16 | } 17 | 18 | result := solution(n, k) 19 | fmt.Println(result) 20 | } 21 | 22 | func solution(n, k int) int { 23 | if n < 2 { 24 | return 1 25 | } 26 | 27 | var result int 28 | ab := []int{1, 1} 29 | k = int(math.Pow(10, float64(k))) 30 | 31 | for i := 0; i < n-1; i++ { 32 | s := (ab[0] + ab[1]) % k 33 | ab[0] = ab[1] 34 | ab[1] = s 35 | result = ab[1] 36 | } 37 | 38 | return result 39 | } 40 | 41 | // getInputData парсинг входных данных 42 | func getInputData() (n, k int, err error) { 43 | 44 | reader := bufio.NewReader(os.Stdin) 45 | 46 | strNum, _, _ := reader.ReadLine() 47 | strExp := strings.Split(string(strNum), " ") 48 | 49 | n, err = strconv.Atoi(strExp[0]) 50 | if err != nil { 51 | return 52 | } 53 | 54 | k, err = strconv.Atoi(strExp[1]) 55 | if err != nil { 56 | return 57 | } 58 | 59 | defer reader.Reset(reader) 60 | return 61 | } 62 | 63 | // showError вывод ошибки 64 | func showError(err error) { 65 | panic(err) 66 | } 67 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_2/tasks/L/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "testing" 6 | ) 7 | 8 | type task struct { 9 | Input []int 10 | Result int 11 | } 12 | 13 | func TestTask(t *testing.T) { 14 | 15 | var taskItems = generateTasks() 16 | 17 | for i := 0; i < len(taskItems); i++ { 18 | t.Run(fmt.Sprintf("Test %d", i+1), func(t *testing.T) { 19 | res := solution(taskItems[i].Input[0], taskItems[i].Input[1]) 20 | if res != taskItems[i].Result { 21 | t.Errorf("Неверный ответ решения!\nОтвет: %d \nВерно: %d", res, taskItems[i].Result) 22 | } 23 | }) 24 | } 25 | } 26 | 27 | // generateTasks создает задачи для теста 28 | func generateTasks() (tasks []task) { 29 | tasks = append( 30 | tasks, 31 | task{ 32 | Input: []int{3, 1}, 33 | Result: 3, 34 | }, 35 | task{ 36 | Input: []int{10, 1}, 37 | Result: 9, 38 | }, 39 | task{ 40 | Input: []int{237, 7}, 41 | Result: 471519, 42 | }, 43 | task{ 44 | Input: []int{1000000, 8}, 45 | Result: 26937501, 46 | }, 47 | ) 48 | 49 | return 50 | } 51 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_3/final/A/input.txt: -------------------------------------------------------------------------------- 1 | 100 2 | 25 3 | 3271 3298 3331 3397 3407 3524 3584 3632 3734 3797 3942 4000 4180 4437 4464 4481 4525 4608 4645 4803 4804 4884 4931 4965 5017 5391 5453 5472 5671 5681 5959 6045 6058 6301 6529 6621 6961 7219 7291 7372 7425 7517 7600 7731 7827 7844 7987 8158 8169 8265 8353 8519 8551 8588 8635 9209 9301 9308 9336 9375 9422 9586 9620 9752 9776 9845 9906 9918 16 25 45 152 199 309 423 614 644 678 681 725 825 830 936 1110 1333 1413 1617 1895 1938 2107 2144 2184 2490 2517 2769 2897 2970 3023 3112 3156 4 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_3/final/A/task.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // brokenSearch основная функция 4 | func brokenSearch(arr []int, k int) int { 5 | return binarySearch(arr, k, 0, len(arr)-1) 6 | } 7 | 8 | // binarySearch бинарный поиск по массиву 9 | func binarySearch(arr []int, k, left, right int) int { 10 | 11 | if left > right { 12 | return -1 13 | } 14 | 15 | mid := (right + left) / 2 16 | if arr[mid] == k { 17 | return mid 18 | } 19 | 20 | // если левая часть отсортирована 21 | if arr[left] <= arr[mid] { 22 | if k >= arr[left] && k <= arr[mid] { 23 | right = mid - 1 24 | } else { 25 | left = mid + 1 26 | } 27 | // тогда по правой стороне 28 | } else { 29 | if k >= arr[mid] && k <= arr[right] { 30 | left = mid + 1 31 | } else { 32 | right = mid - 1 33 | } 34 | } 35 | 36 | // рекурсивно идем дальше с учетём измененного отрезка 37 | return binarySearch(arr, k, left, right) 38 | } 39 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_3/final/B/input.txt: -------------------------------------------------------------------------------- 1 | 5 2 | alla 4 100 3 | gena 6 1000 4 | gosha 2 90 5 | rita 2 90 6 | timofey 4 80 7 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_3/tasks/A/task.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "strings" 6 | ) 7 | 8 | func main() { 9 | 10 | var n int 11 | fmt.Scan(&n) 12 | 13 | res := strings.Builder{} 14 | solution(n, "", 0, 0, &res) 15 | fmt.Println(strings.TrimRight(res.String(), "\n")) 16 | } 17 | 18 | func solution(n int, line string, l, r int, s *strings.Builder) { 19 | if l == n && r == n { 20 | s.WriteString(line + "\n") 21 | } else { 22 | if l < n { 23 | solution(n, line+"(", l+1, r, s) 24 | } 25 | if r < l { 26 | solution(n, line+")", l, r+1, s) 27 | } 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_3/tasks/A/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "strings" 6 | "testing" 7 | ) 8 | 9 | type task struct { 10 | N int 11 | Result string 12 | } 13 | 14 | func TestTask(t *testing.T) { 15 | 16 | var taskItems = generateTasks() 17 | 18 | for i := 0; i < len(taskItems); i++ { 19 | t.Run(fmt.Sprintf("Test %d", i+1), func(t *testing.T) { 20 | s := strings.Builder{} 21 | solution(taskItems[i].N, "", 0, 0, &s) 22 | if strings.TrimRight(s.String(), "\n") != taskItems[i].Result { 23 | t.Errorf("Неверный ответ решения!\nОтвет: %s \nВерно: %s", s.String(), taskItems[i].Result) 24 | } 25 | }) 26 | } 27 | } 28 | 29 | func generateTasks() (tasks []task) { 30 | tasks = append( 31 | tasks, 32 | task{ 33 | N: 3, 34 | Result: `((())) 35 | (()()) 36 | (())() 37 | ()(()) 38 | ()()()`}, 39 | task{ 40 | N: 2, 41 | Result: `(()) 42 | ()()`}, 43 | ) 44 | 45 | return 46 | } 47 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_3/tasks/B/README.md: -------------------------------------------------------------------------------- 1 | # B. Комбинации 2 | 3 | На клавиатуре старых мобильных телефонов каждой цифре соответствовало несколько букв. 4 | 5 | Примерно так: 6 | 7 | 2:'abc',
8 | 3:'def',
9 | 4:'ghi',
10 | 5:'jkl',
11 | 6:'mno',
12 | 7:'pqrs',
13 | 8:'tuv',
14 | 9:'wxyz'
15 | 16 | Вам известно в каком порядке были нажаты кнопки телефона, без учета повторов. Напечатайте все комбинации букв, которые можно набрать такой последовательностью нажатий. 17 | 18 | ![IMG](https://contest.yandex.ru/testsys/statement-image?imageId=c9a2bef9474efcb47fabe3c0be11d7bde9a773ec32dfb68486bddef964647ac7) 19 | 20 | ## Формат ввода 21 | 22 | На вход подается строка, состоящая из цифр 2-9 включительно. Длина строки не превосходит 10 символов. 23 | 24 | ## Формат вывода 25 | 26 | Выведите все возможные комбинации букв через пробел. 27 | 28 | ### Пример 1 29 | 30 | 31 | 32 | 33 | 34 | 35 |
23ad ae af bd be bf cd ce cf
36 | 37 | ### Пример 2 38 | 39 | 40 | 41 | 42 | 43 | 44 |
92wa wb wc xa xb xc ya yb yc za zb zc
45 | 46 | 47 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_3/tasks/B/task.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "strings" 6 | ) 7 | 8 | var numberRules = map[string]string{ 9 | "2": "abc", 10 | "3": "def", 11 | "4": "ghi", 12 | "5": "jkl", 13 | "6": "mno", 14 | "7": "pqrs", 15 | "8": "tuv", 16 | "9": "wxyz", 17 | } 18 | 19 | func main() { 20 | var input string 21 | _, _ = fmt.Scan(&input) 22 | 23 | fmt.Println(strings.Trim(fmt.Sprint(solution(input)), "[]")) 24 | } 25 | 26 | func solution(digits string) []string { 27 | if digits == "" { 28 | return nil 29 | } 30 | 31 | var result []string 32 | var words = numberRules[digits[len(digits)-1:]] 33 | var combinations = solution(digits[:len(digits)-1]) 34 | 35 | if len(combinations) > 0 { 36 | for _, combination := range combinations { 37 | for _, c := range strings.Split(words, "") { 38 | result = append(result, combination+c) 39 | } 40 | } 41 | } else { 42 | for _, c := range strings.Split(words, "") { 43 | result = append(result, c) 44 | } 45 | } 46 | 47 | return result 48 | } 49 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_3/tasks/B/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "strings" 6 | "testing" 7 | ) 8 | 9 | type task struct { 10 | Input string 11 | Result string 12 | } 13 | 14 | func TestTask(t *testing.T) { 15 | var taskItems = generateTasks() 16 | for i := 0; i < len(taskItems); i++ { 17 | t.Run(fmt.Sprintf("Test %d", i+1), func(t *testing.T) { 18 | res := solution(taskItems[i].Input) 19 | if strings.Trim(fmt.Sprint(res), "[]") != taskItems[i].Result { 20 | t.Errorf("Неверный ответ решения!\nОтвет: %s \nВерно: %s", res, taskItems[i].Result) 21 | } 22 | }) 23 | } 24 | } 25 | 26 | func generateTasks() (tasks []task) { 27 | tasks = append( 28 | tasks, 29 | task{ 30 | Input: "23", 31 | Result: "ad ae af bd be bf cd ce cf", 32 | }, 33 | task{ 34 | Input: "92", 35 | Result: "wa wb wc xa xb xc ya yb yc za zb zc", 36 | }, 37 | ) 38 | 39 | return 40 | } 41 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_3/tasks/C/README.md: -------------------------------------------------------------------------------- 1 | # C. Подпоследовательность 2 | 3 | Гоша любит играть в игру «Подпоследовательность»: даны 2 строки, и нужно понять, является ли первая из них подпоследовательностью второй. Когда строки достаточно длинные, очень трудно получить ответ на этот вопрос, просто посмотрев на них. Помогите Гоше написать функцию, которая решает эту задачу. 4 | 5 | 6 | ## Формат ввода 7 | 8 | В первой строке записана строка s. 9 | 10 | Во второй —- строка t. 11 | 12 | Обе строки состоят из маленьких латинских букв, длины строк не превосходят 150000. Строки могут быть пустыми. 13 | 14 | ## Формат вывода 15 | 16 | Выведите True, если s является подпоследовательностью t, иначе —– False. 17 | 18 | 19 | ### Пример 1 20 | 21 | 22 | 23 | 27 | 28 | 29 |
24 | abc
25 | ahbgdcu
26 | 		True

30 | 31 | 32 | ### Пример 2 33 | 34 | 35 | 36 | 37 | 41 | 42 | 43 |
38 | abcp
39 | ahpc 40 | 		False

44 | 45 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_3/tasks/C/input.txt: -------------------------------------------------------------------------------- 1 | ijha 2 | hmrqvftefyixinahlzgbkidroxiptbbkjmtwpsujevkulgrjiwiwzyhngulrodiwyg 3 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_3/tasks/C/task.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bufio" 5 | "fmt" 6 | "os" 7 | ) 8 | 9 | func main() { 10 | str1, str2, err := getInputData() 11 | if err != nil { 12 | showError(err) 13 | } 14 | 15 | fmt.Println(solution(str1, str2)) 16 | } 17 | 18 | func solution(s, t string) string { 19 | lenS, lenT := len(s), len(t) 20 | if lenS == 0 || s == " " || s == t { 21 | return "True" 22 | } 23 | 24 | if lenS > lenT { 25 | return "False" 26 | } 27 | 28 | var i, j int 29 | for j < lenT { 30 | if s[i] == t[j] { 31 | i++ 32 | if i >= lenS { 33 | return "True" 34 | } 35 | } 36 | j++ 37 | } 38 | 39 | return "False" 40 | } 41 | 42 | func getInputData() (s, t string, err error) { 43 | var input *os.File 44 | 45 | input, err = getInputFromFile() 46 | if err != nil { 47 | showError(err) 48 | } 49 | // close file 50 | defer func(input *os.File) { 51 | _ = input.Close() 52 | }(input) 53 | 54 | reader := bufio.NewReader(input) 55 | s, _ = reader.ReadString('\n') 56 | t, _ = reader.ReadString('\n') 57 | 58 | return 59 | } 60 | 61 | func getInputFromFile() (*os.File, error) { 62 | file, err := os.Open("input.txt") 63 | if err != nil { 64 | return nil, err 65 | } 66 | 67 | return file, nil 68 | } 69 | 70 | func showError(err interface{}) { 71 | panic(err) 72 | } 73 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_3/tasks/D/input.txt: -------------------------------------------------------------------------------- 1 | 2 2 | 1 2 3 | 3 4 | 2 1 3 5 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_3/tasks/D/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_3/tasks/E/README.md: -------------------------------------------------------------------------------- 1 | # E. Покупка домов 2 | 3 | Тимофей решил купить несколько домов на знаменитом среди разработчиков Алгосском архипелаге. Он нашёл n объявлений о продаже, где указана стоимость каждого дома в алгосских франках. А у Тимофея есть k франков. Помогите ему определить, какое наибольшее количество домов на Алгосах он сможет приобрести за эти деньги. 4 | 5 | ## Формат ввода 6 | 7 | В первой строке через пробел записаны натуральные числа n и k. 8 | 9 | n — количество домов, которые рассматривает Тимофей, оно не превосходит 1000; 10 | 11 | k — общий бюджет, не превосходит 10000; 12 | 13 | В следующей строке через пробел записано n стоимостей домов. Каждое из чисел не превосходит 10000. Все стоимости — натуральные числа. 14 | 15 | ## Формат вывода 16 | 17 | Выведите одно число —– наибольшее количество домов, которое может купить Тимофей. 18 | 19 | ### Пример 1 20 | 21 | 22 | 23 | 27 | 32 |
24 | 3 300
25 | 999 999 999 26 | 		28 | 0 29 |
30 |
31 |
33 | 34 | ### Пример 2 35 | 36 | 37 | 38 | 42 | 47 |
39 | 3 1000
40 | 350 999 200 41 | 		43 | 2 44 |
45 |
46 |
-------------------------------------------------------------------------------- /yandex_practicum/sprint_3/tasks/E/task.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_3/tasks/E/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_3/tasks/F/task.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_3/tasks/F/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_3/tasks/G/README.md: -------------------------------------------------------------------------------- 1 | # G. Гардероб 2 | 3 | Рита решила оставить у себя одежду только трёх цветов: розового, жёлтого и малинового. После того как вещи других расцветок были убраны, Рита захотела отсортировать свой новый гардероб по цветам. Сначала должны идти вещи розового цвета, потом —– жёлтого, и в конце —– малинового.
4 | Помогите Рите справиться с этой задачей. 5 | 6 | Примечание: попробуйте решить задачу за один проход по массиву! 7 | 8 | ## Формат ввода 9 | 10 | В первой строке задано количество предметов в гардеробе: n –— оно не превосходит 1000000. Во второй строке даётся массив, в котором указан цвет для каждого предмета. 11 | 12 | Розовый цвет обозначен 0, жёлтый —– 1, малиновый –— 2. 13 | 14 | ## Формат вывода 15 | 16 | Нужно вывести в строку через пробел цвета предметов в правильном порядке. 17 | 18 | ### Пример 1 19 | 20 | 21 | 25 | 30 |
22 | 7
23 | 0 2 1 2 0 0 1 24 | 		26 | 0 0 0 1 1 2 2 27 |
28 |
29 |
31 | 32 | ### Пример 2 33 | 34 | 35 | 39 | 44 |
36 | 5
37 | 2 1 2 0 1 38 | 		40 | 0 1 1 2 2 41 |
42 |
43 |
45 | 46 | ### Пример 3 47 | 48 | 49 | 53 | 58 |
50 | 6
51 | 2 1 1 2 0 2 52 | 		54 | 0 1 1 2 2 2 55 |
56 |
57 |
59 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_3/tasks/G/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_3/tasks/H/README.md: -------------------------------------------------------------------------------- 1 | # H. Большое число 2 | 3 | Вечером ребята решили поиграть в игру «Большое число». 4 | Даны числа. Нужно определить, какое самое большое число можно из них составить. 5 | 6 | ## Формат ввода 7 | 8 | В первой строке записано n — количество чисел. Оно не превосходит 100. 9 | Во второй строке через пробел записаны n неотрицательных чисел, каждое из которых не превосходит 1000. 10 | 11 | ## Формат вывода 12 | 13 | Нужно вывести самое большое число, которое можно составить из данных чисел. 14 | 15 | 16 | ### Пример 1 17 | 18 | 19 | 23 | 28 |
20 | 3
21 | 15 56 2 22 | 		24 | 56215 25 |
26 |
27 |
29 | 30 | ### Пример 2 31 | 32 | 33 | 37 | 42 |
34 | 3
35 | 1 783 2 36 | 		38 | 78321 39 |
40 |
41 |
43 | 44 | ### Пример 3 45 | 46 | 47 | 51 | 56 |
48 | 5
49 | 2 4 5 2 10 50 | 		52 | 542210 53 |
54 |
55 |
-------------------------------------------------------------------------------- /yandex_practicum/sprint_3/tasks/H/input.txt: -------------------------------------------------------------------------------- 1 | 5 2 | 2 4 5 2 10 3 | 4 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_3/tasks/H/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_3/tasks/I/README.md: -------------------------------------------------------------------------------- 1 | # I. Любители конференций 2 | 3 | На IT-конференции присутствовали студенты из разных вузов со всей страны. Для каждого студента известен ID университета, в котором он учится. 4 | 5 | Тимофей предложил Рите выяснить, из каких k вузов на конференцию пришло больше всего учащихся. 6 | 7 | ## Формат ввода 8 | 9 | В первой строке дано количество студентов в списке —– n (1 ≤ n ≤ 15 000).
10 | Во второй строке через пробел записаны n целых чисел —– ID вуза каждого студента. Каждое из чисел находится в диапазоне от 0 до 10 000. 11 | 12 | В третьей строке записано одно число k. 13 | 14 | ## Формат вывода 15 | 16 | Выведите через пробел k ID вузов с максимальным числом участников. 17 | 18 | Они должны быть отсортированы по убыванию популярности (по количеству гостей от конкретного вуза). Если более одного вуза имеет одно и то же количество учащихся, то выводить их ID нужно в порядке возрастания. 19 | 20 | 21 | ### Пример 1 22 | 23 | 24 | 29 | 35 |
25 | 7
26 | 1 2 3 1 2 3 4
27 | 3 28 | 		30 | 1 2 3 31 |
32 |
33 |
34 |
36 | 37 | ### Пример 2 38 | 39 | 40 | 45 | 51 |
41 | 6
42 | 1 1 1 2 2 3
43 | 1 44 | 		46 | 1 47 |
48 |
49 |
50 |
-------------------------------------------------------------------------------- /yandex_practicum/sprint_3/tasks/I/task.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_3/tasks/I/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_3/tasks/J/input.txt: -------------------------------------------------------------------------------- 1 | 5 2 | 1 1 1 1 1 3 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_3/tasks/J/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_3/tasks/K/input.txt: -------------------------------------------------------------------------------- 1 | 2 2 | -19 -3 -------------------------------------------------------------------------------- /yandex_practicum/sprint_3/tasks/K/task.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func merge(arr []int, left int, mid int, right int) []int { 4 | midCopy := mid 5 | result := make([]int, 0, right-left) 6 | 7 | for left < mid || midCopy < right { 8 | if left == mid { 9 | result = append(result, arr[midCopy]) 10 | midCopy++ 11 | continue 12 | } 13 | if midCopy == right { 14 | result = append(result, arr[left]) 15 | left++ 16 | continue 17 | } 18 | if arr[left] <= arr[midCopy] { 19 | result = append(result, arr[left]) 20 | left++ 21 | } else { 22 | result = append(result, arr[midCopy]) 23 | midCopy++ 24 | } 25 | } 26 | 27 | return result 28 | } 29 | 30 | func merge_sort(arr []int, lf int, rg int) { 31 | if rg-lf <= 1 { 32 | return 33 | } 34 | 35 | mid := (lf + rg) / 2 36 | merge_sort(arr, lf, mid) 37 | merge_sort(arr, mid, rg) 38 | 39 | res := merge(arr, lf, mid, rg) 40 | 41 | k := 0 42 | for i := lf; i < rg; i++ { 43 | arr[i] = res[k] 44 | k++ 45 | } 46 | } 47 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_3/tasks/K/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_3/tasks/L/input.txt: -------------------------------------------------------------------------------- 1 | 6 2 | 1 2 4 4 6 8 3 | 3 -------------------------------------------------------------------------------- /yandex_practicum/sprint_3/tasks/L/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "testing" 6 | ) 7 | 8 | type task struct { 9 | N, X int 10 | Days []int 11 | Result []int 12 | } 13 | 14 | func TestTask(t *testing.T) { 15 | 16 | var taskItems = generateTasks() 17 | 18 | for i := 0; i < len(taskItems); i++ { 19 | t.Run(fmt.Sprintf("Test %d", i+1), func(t *testing.T) { 20 | res := solution(taskItems[i].N, taskItems[i].X, taskItems[i].Days) 21 | if fmt.Sprint(res) != fmt.Sprint(taskItems[i].Result) { 22 | t.Errorf("Неверный ответ решения!\nОтвет: %v \nВерно: %v", res, taskItems[i].Result) 23 | } else { 24 | t.Log("OK") 25 | } 26 | }) 27 | } 28 | } 29 | 30 | // generateTasks создает задачи для теста 31 | func generateTasks() (tasks []task) { 32 | tasks = append( 33 | tasks, 34 | task{ 35 | N: 6, 36 | X: 10, 37 | Days: []int{1, 2, 4, 4, 4, 4}, 38 | Result: []int{-1, -1}, 39 | }, 40 | task{ 41 | N: 7, 42 | X: 3, 43 | Days: []int{1, 1, 4, 4, 4, 4, 8}, 44 | Result: []int{3, 7}, 45 | }, 46 | task{ 47 | N: 6, 48 | X: 1, 49 | Days: []int{1, 2, 4, 4, 4, 4}, 50 | Result: []int{1, 2}, 51 | }, 52 | task{ 53 | N: 17, 54 | X: 28, 55 | Days: []int{12, 19, 29, 31, 33, 37, 52, 62, 66, 68, 71, 75, 75, 88, 90, 93, 98}, 56 | Result: []int{3, 8}, 57 | }, 58 | ) 59 | 60 | return 61 | } 62 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_3/tasks/M/task.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_3/tasks/M/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_3/tasks/N/task.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_3/tasks/N/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_3/tasks/O/task.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_3/tasks/O/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_3/tasks/P/input.txt: -------------------------------------------------------------------------------- 1 | 8 2 | 3 6 7 4 1 5 0 2 -------------------------------------------------------------------------------- /yandex_practicum/sprint_3/tasks/P/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_4/final/A/input.txt: -------------------------------------------------------------------------------- 1 | 6 2 | buy flat in moscow 3 | rent flat in moscow 4 | sell flat in moscow 5 | want flat in moscow like crazy 6 | clean flat in moscow on weekends 7 | renovate flat in moscow 8 | 1 9 | flat in moscow for crazy weekends 10 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_4/final/B/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "strings" 6 | "testing" 7 | ) 8 | 9 | type task struct { 10 | N int 11 | Input []string 12 | Result []string 13 | } 14 | 15 | func TestTask(t *testing.T) { 16 | tasks := generateTasks() 17 | for i := 0; i < len(tasks); i++ { 18 | t.Run(fmt.Sprintf("Test %d", i+1), func(t *testing.T) { 19 | res := testMain(tasks[i].N, tasks[i].Input) 20 | if strings.Join(res, "") != strings.Join(tasks[i].Result, "") { 21 | t.Errorf("Неверный ответ решения!\nОтвет: %v \nВерно: %v", res, tasks[i].Result) 22 | } 23 | }) 24 | } 25 | } 26 | 27 | func generateTasks() []*task { 28 | return []*task{ 29 | { 30 | N: 10, 31 | Input: []string{ 32 | "get 1", 33 | "put 1 10", 34 | "put 2 4", 35 | "get 1", 36 | "get 2", 37 | "delete 2", 38 | "get 2", 39 | "put 1 5", 40 | "get 1", 41 | "delete 2", 42 | }, 43 | Result: []string{ 44 | "None", 45 | "10", 46 | "4", 47 | "4", 48 | "None", 49 | "5", 50 | "None", 51 | }, 52 | }, 53 | { 54 | N: 8, 55 | Input: []string{ 56 | "get 9", 57 | "delete 9", 58 | "put 9 1", 59 | "get 9", 60 | "put 9 2", 61 | "get 9", 62 | "put 9 3", 63 | "get 9", 64 | }, 65 | Result: []string{ 66 | "None", 67 | "None", 68 | "1", 69 | "2", 70 | "3", 71 | }, 72 | }, 73 | } 74 | } 75 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_4/tasks/A/README.md: -------------------------------------------------------------------------------- 1 | # A. Полиномиальный хеш 2 | 3 | Алле очень понравился алгоритм вычисления полиномиального хеша. Помогите ей написать функцию, вычисляющую хеш строки s. В данной задаче необходимо использовать в качестве значений отдельных символов их коды в таблице ASCII. 4 | 5 | Полиномиальный хеш считается по формуле: 6 | 7 | ![IMG](https://contest.yandex.ru/testsys/tex/render/aChzKSA9IChzXzFhXntuLTF9ICsgc18yYV57bi0yfSArIFxkb3RzICsgc197bi0xfWEgKyBzX3tufSkgXCBtb2QgXCBt.png) 8 | 9 | ## Формат ввода 10 | В первой строке дано число a (1 ≤ a ≤ 1000) –— основание, по которому считается хеш. 11 | 12 | Во второй строке дано число m (1 ≤ m ≤ 109) –— модуль. 13 | 14 | В третьей строке дана строка s (0 ≤ |s| ≤ 106), состоящая из больших и маленьких латинских букв. 15 | 16 | ## Формат вывода 17 | Выведите целое неотрицательное число –— хеш заданной строки. 18 | 19 | ### Пример 1 20 | 21 | 22 | 27 | 32 |
23 | 123
24 | 100003
25 | a 26 | 		28 | 97
29 |
30 |
31 |
33 | 34 | ### Пример 2 35 | 36 | 37 | 42 | 47 |
38 | 123
39 | 100003
40 | hash 41 | 		43 | 6080
44 |
45 |
46 |
48 | 49 | ### Пример 3 50 | 51 | 52 | 57 | 62 |
53 | 123
54 | 100003
55 | HaSH 56 | 		58 | 6080
59 |
60 |
61 |
-------------------------------------------------------------------------------- /yandex_practicum/sprint_4/tasks/A/input.txt: -------------------------------------------------------------------------------- 1 | 123 2 | 100003 3 | a 4 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_4/tasks/B/README.md: -------------------------------------------------------------------------------- 1 | # B. Сломай меня 2 | 3 | Гоша написал программу, которая сравнивает строки исключительно по их хешам. Если хеш равен, то и строки равны. Тимофей увидел это безобразие и поручил вам сломать программу Гоши, чтобы остальным неповадно было. 4 | 5 | В этой задаче вам надо будет лишь найти две различные строки, которые для заданной хеш-функции будут давать одинаковое значение. 6 | 7 | Гоша использует следующую хеш-функцию: 8 | 9 | ![IMG](https://contest.yandex.ru/testsys/tex/render/aChzKSA9IChzXzFhXntuLTF9ICsgc18yYV57bi0yfSArIC4uLiArIHNfe24tMX1hICsgc197bn0gKSBcICBtb2QgXCBt.png) 10 | 11 | для a = 1000 и m = 123 987 123. 12 | 13 | В данной задаче необходимо использовать в качестве значений отдельных символов их коды в таблице ASCII. 14 | 15 | ## Формат ввода 16 | В задаче единственный тест без ввода 17 | 18 | ## Формат вывода 19 | Отправьте две строки, по одной в строке. Строки могут состоять только из маленьких латинских букв и не должны превышать в длину 1000 знаков каждая. Код отправлять не требуется. Строки из примера использовать нельзя. 20 | 21 | #### Пример вывода: 22 | 23 | ezhgeljkablzwnvuwqvp 24 | 25 | gbpdcvkumyfxillgnqrv 26 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_4/tasks/C/input.txt: -------------------------------------------------------------------------------- 1 | 1000 2 | 1000009 3 | abcdefgh 4 | 7 5 | 1 1 6 | 1 5 7 | 2 3 8 | 3 4 9 | 4 4 10 | 1 8 11 | 5 8 12 | 13 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_4/tasks/D/README.md: -------------------------------------------------------------------------------- 1 | # D. Кружки 2 | 3 | В компании, где работает Тимофей, заботятся о досуге сотрудников и устраивают различные кружки по интересам. Когда кто-то записывается на занятие, в лог вносится название кружка. 4 | По записям в логе составьте список всех кружков, в которые ходит хотя бы один человек. 5 | 6 | ## Формат ввода 7 | В первой строке даётся натуральное число n, не превосходящее 10 000 –— количество записей в логе. 8 | 9 | В следующих n строках —– названия кружков. 10 | 11 | ## Формат вывода 12 | Выведите уникальные названия кружков по одному на строке, в порядке появления во входных данных. 13 | 14 | ### Пример 15 | 16 | 17 | 28 | 39 |
18 | 8
19 | вышивание крестиком
20 | рисование мелками на парте
21 | настольный керлинг
22 | настольный керлинг
23 | кухня африканского племени ужасмай
24 | тяжелая атлетика
25 | таракановедение
26 | таракановедение
27 | 		29 | вышивание крестиком
30 | рисование мелками на парте
31 | настольный керлинг
32 | кухня африканского племени ужасмай
33 | тяжелая атлетика
34 | таракановедение
35 |
36 |
37 |
38 |
-------------------------------------------------------------------------------- /yandex_practicum/sprint_4/tasks/D/input.txt: -------------------------------------------------------------------------------- 1 | 8 2 | вышивание крестиком 3 | рисование мелками на парте 4 | настольный керлинг 5 | настольный керлинг 6 | кухня африканского племени ужасмай 7 | тяжелая атлетика 8 | таракановедение 9 | таракановедение 10 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_4/tasks/D/task.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bufio" 5 | "fmt" 6 | "os" 7 | "strconv" 8 | ) 9 | 10 | func main() { 11 | var input *os.File 12 | var bufStr string 13 | var err error 14 | var n int 15 | 16 | input, err = getInputFromFile() 17 | if err != nil { 18 | showError(err) 19 | } 20 | // close file 21 | defer func(input *os.File) { 22 | _ = input.Close() 23 | }(input) 24 | 25 | scanner := bufio.NewScanner(input) 26 | scanner.Split(bufio.ScanLines) 27 | 28 | scanner.Scan() 29 | bufStr = scanner.Text() 30 | n, err = strconv.Atoi(bufStr) 31 | if err != nil { 32 | return 33 | } 34 | 35 | items := make(map[string]bool, n) 36 | 37 | for i := 0; i < n; i++ { 38 | scanner.Scan() 39 | bufStr = scanner.Text() 40 | if _, ok := items[bufStr]; !ok { 41 | fmt.Println(bufStr) 42 | items[bufStr] = true 43 | } 44 | } 45 | } 46 | 47 | func getInputFromFile() (*os.File, error) { 48 | file, err := os.Open("input.txt") 49 | if err != nil { 50 | return nil, err 51 | } 52 | 53 | return file, nil 54 | } 55 | 56 | func showError(err interface{}) { 57 | panic(err) 58 | } 59 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_4/tasks/E/README.md: -------------------------------------------------------------------------------- 1 | # E. Подстроки 2 | 3 | На вход подается строка. Нужно определить длину наибольшей подстроки, которая не содержит повторяющиеся символы. 4 | 5 | ## Формат ввода 6 | 7 | Одна строка, состоящая из строчных латинских букв. Длина строки не превосходит 10 000. 8 | 9 | ## Формат вывода 10 | 11 | Выведите натуральное число —– ответ на задачу. 12 | 13 | ### Пример 1 14 | 15 | 16 | 19 | 22 |
17 | abcabcbb 18 | 20 | 3 21 |
23 | 24 | ### Пример 2 25 | 26 | 27 | 30 | 33 |
28 | bbbbb 29 | 31 | 1 32 |
34 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_4/tasks/E/input.txt: -------------------------------------------------------------------------------- 1 | abcabcbb 2 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_4/tasks/G/README.md: -------------------------------------------------------------------------------- 1 | # G. Соревнование 2 | 3 | Жители Алгосов любят устраивать турниры по спортивному программированию. Все участники разбиваются на пары и соревнуются друг с другом. А потом два самых сильных программиста встречаются в финальной схватке, которая состоит из нескольких раундов. Если в очередном раунде выигрывает первый участник, в таблицу с результатами записывается 0, если второй, то 1. Ничьей в раунде быть не может. 4 | 5 | Нужно определить наибольший по длине непрерывный отрезок раундов, по результатам которого суммарно получается ничья. Например, если дана последовательность 0 0 1 0 1 1 1 0 0 0, то раунды с 2-го по 9-й (нумерация начинается с единицы) дают ничью. 6 | 7 | ## Формат ввода 8 | 9 | В первой строке задаётся n (0 ≤ n ≤ 105) –— количество раундов. Во второй строке через пробел записано n чисел –— результаты раундов. Каждое число равно либо 0, либо 1. 10 | 11 | ## Формат вывода 12 | 13 | Выведите длину найденного отрезка. 14 | 15 | ### Пример 1 16 | 17 | 18 | 22 | 26 |
19 | 2
20 | 0 1 21 | 		23 | 2
24 |
25 |
27 | 28 | ### Пример 2 29 | 30 | 31 | 35 | 39 |
32 | 3
33 | 0 1 0 34 | 		36 | 2
37 |
38 |
40 | 41 | 42 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_4/tasks/G/input.txt: -------------------------------------------------------------------------------- 1 | 2 2 | 0 1 3 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_4/tasks/H/input.txt: -------------------------------------------------------------------------------- 1 | mxyskaoghi 2 | qodfrgmslc 3 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_4/tasks/I/input.txt: -------------------------------------------------------------------------------- 1 | 5 2 | 1 2 3 2 1 3 | 5 4 | 3 2 1 5 6 5 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_4/tasks/J/README.md: -------------------------------------------------------------------------------- 1 | # J. Сумма четвёрок 2 | 3 | У Гоши есть любимое число S. Помогите ему найти все уникальные четвёрки чисел в массиве, которые в сумме дают заданное число S. 4 | 5 | ## Формат ввода 6 | 7 | В первой строке дано общее количество элементов массива n (0 ≤ n ≤ 1000). 8 | 9 | Во второй строке дано целое число S. 10 | 11 | В третьей строке задан сам массив. Каждое число является целым и не превосходит по модулю 109. 12 | 13 | ## Формат вывода 14 | 15 | В первой строке выведите количество найденных четвёрок чисел. 16 | 17 | В последующих строках выведите найденные четвёрки. Числа внутри одной четверки должны быть упорядочены по возрастанию. Между собой четвёрки упорядочены лексикографически. 18 | 19 | ### Пример 1 20 | 21 | 22 | 28 | 34 |
23 | 8
24 | 10
25 | 2 3 2 4 1 10 3 0
26 |
27 | 		29 | 3
30 | 0 3 3 4
31 | 1 2 3 4
32 | 2 2 3 3 33 |
35 | 36 | ### Пример 3 37 | 38 | 39 | 45 | 51 |
40 | 6
41 | 0
42 | 1 0 -1 0 2 -2 43 |
44 | 		46 | 3
47 | -2 -1 1 2
48 | -2 0 0 2
49 | -1 0 0 1 50 |
52 | 53 | ### Пример 2 54 | 55 | 56 | 61 | 66 |
57 | 5
58 | 4
59 | 1 1 1 1 1 60 | 		62 | 1
63 | 1 1 1 1
64 |
65 |
67 | 68 | 69 | 70 | 71 | 72 | 73 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_4/tasks/J/input.txt: -------------------------------------------------------------------------------- 1 | 8 2 | 10 3 | 2 3 2 4 1 10 3 0 4 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_4/tasks/L/README.md: -------------------------------------------------------------------------------- 1 | # L. МногоГоша 2 | 3 | Дана длинная строка, состоящая из маленьких латинских букв. Нужно найти все её подстроки длины n, которые встречаются хотя бы k раз. 4 | 5 | ## Формат ввода 6 | 7 | В первой строчке через пробел записаны два натуральных числа n и k. 8 | 9 | Во второй строчке записана строка, состоящая из маленьких латинских букв. 10 | 11 | Длина строки 1 ≤ L ≤ 106. 12 | 13 | n ≤ L, k ≤ L. 14 | 15 | ## Формат вывода 16 | 17 | Для каждой найденной подстроки выведите индекс начала её первого вхождения (нумерация в строке начинается с нуля). 18 | 19 | Выводите индексы в любом порядке, в одну строку, через пробел. 20 | 21 | ### Пример 1 22 | 23 | 24 | 28 | 33 |
25 | 10 2
26 | gggggooooogggggoooooogggggssshaa 27 | 		29 | 0 5
30 |
31 | 32 |
34 | 35 | ### Пример 2 36 | 37 | 38 | 42 | 46 |
39 | 3 4
40 | allallallallalla 41 | 		43 | 0 1 2
44 |
45 |
47 | 48 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_5/tasks/A/README.md: -------------------------------------------------------------------------------- 1 | # A. Лампочки 2 | 3 | Гоша повесил на стену гирлянду в виде бинарного дерева, в узлах которого находятся лампочки. У каждой лампочки есть своя яркость. Уровень яркости лампочки соответствует числу, расположенному в узле дерева. Помогите Гоше найти самую яркую лампочку в гирлянде, то есть такую, у которой яркость наибольшая. 4 | 5 | ![IMG](img.png) 6 | 7 | ## Формат ввода 8 | На вход подается корень дерева. 9 | 10 | **Замечания про отправку решений** 11 | 12 | По умолчанию выбран компилятор make. 13 | Решение нужно отправлять в виде файла с расширением, которое соответствует вашему языку программирования. 14 | 15 | Go: 16 | 17 | ```go 18 | package main 19 | 20 | 21 | /** 22 | Comment it before submitting 23 | type Node struct { 24 | value int 25 | left *Node 26 | right *Node 27 | } 28 | **/ 29 | 30 | func Solution(root *Node) int { 31 | // Your code 32 | // “ヽ(´▽｀)ノ” 33 | } 34 | 35 | func test() { 36 | node1 := Node{1, nil, nil} 37 | node2 := Node{-5, nil, nil} 38 | node3 := Node{3, &node1, &node2} 39 | node4 := Node{2, &node3, nil} 40 | if Solution(&node4) != 3 { 41 | panic("WA") 42 | } 43 | } 44 | 45 | ``` 46 | 47 | 48 | ## Формат вывода 49 | 50 | Функция должна вернуть максимальное значение яркости в узле дерева. 51 | 52 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_5/tasks/A/for_tests.txt: -------------------------------------------------------------------------------- 1 | 10 2 | 0 0 1 2 3 | 1 2 3 None 4 | 2 2 None 4 5 | 3 3 5 6 6 | 4 3 7 8 7 | 5 0 None None 8 | 6 0 None None 9 | 7 111 None None 10 | 8 0 None 9 11 | 9 111 None None 12 | - 13 | 111 14 | 15 | -------- 16 | 17 | 10 18 | 0 0 1 2 19 | 1 2 3 None 20 | 2 2 None 4 21 | 3 3 5 6 22 | 4 3 7 8 23 | 5 0 None None 24 | 6 7771 None None 25 | 7 111 None None 26 | 8 0 None 9 27 | 9 0 None None 28 | - 29 | 7771 30 | 31 | ------- 32 | 33 | 1 34 | 0 1 None None 35 | - 36 | 1 37 | 38 | 39 | -------- 40 | 41 | 2 42 | 0 1 None 1 43 | 1 0 None None 44 | - 45 | 1 -------------------------------------------------------------------------------- /yandex_practicum/sprint_5/tasks/A/img.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dmitryburov/algorithm-practice/1501896081a17ead0f3e5571f9f13cabaf889142/yandex_practicum/sprint_5/tasks/A/img.png -------------------------------------------------------------------------------- /yandex_practicum/sprint_5/tasks/A/task.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // Node 4 | // TODO закомментить перед отправкой 5 | type Node struct { 6 | value int 7 | left *Node 8 | right *Node 9 | } 10 | 11 | var maxValue = 0 12 | 13 | func Solution(root *Node) int { 14 | maxValue = 0 15 | recurse(root) 16 | 17 | return maxValue 18 | } 19 | 20 | func recurse(node *Node) { 21 | if node == nil { 22 | return 23 | } 24 | 25 | if node.value > maxValue { 26 | maxValue = node.value 27 | } 28 | 29 | if node.left != nil { 30 | recurse(node.left) 31 | } 32 | if node.right != nil { 33 | recurse(node.right) 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_5/tasks/B/README.md: -------------------------------------------------------------------------------- 1 | # B. Сбалансированное дерево 2 | 3 | Гоше очень понравилось слушать рассказ Тимофея про деревья. Особенно часть про сбалансированные деревья. Он решил написать функцию, которая определяет, сбалансировано ли дерево. 4 | 5 | Дерево считается сбалансированным, если левое и правое поддеревья каждой вершины отличаются по высоте не больше, чем на единицу. 6 | 7 | ![IMG](image.png) 8 | 9 | ## Формат ввода 10 | 11 | На вход функции подаётся корень бинарного дерева. 12 | 13 | **Замечания про отправку решений** 14 | 15 | По умолчанию выбран компилятор make. Шаблон для Go: 16 | 17 | ```go 18 | package main 19 | 20 | /** 21 | Comment it before submitting 22 | type Node struct { 23 | value int 24 | left *Node 25 | right *Node 26 | } 27 | **/ 28 | 29 | func Solution(root *Node) bool { 30 | // Your code 31 | // “ヽ(´▽｀)ノ” 32 | } 33 | ``` 34 | 35 | ## Формат вывода 36 | 37 | Функция должна вернуть True, если дерево сбалансировано в соответствии с критерием из условия, иначе - False. -------------------------------------------------------------------------------- /yandex_practicum/sprint_5/tasks/B/for tests.txt: -------------------------------------------------------------------------------- 1 | 1 2 | 0 0 None None 3 | - 4 | True 5 | 6 | --------- 7 | 8 | 3 9 | 0 0 1 2 10 | 1 1 None None 11 | 2 2 None None 12 | - 13 | True 14 | 15 | ---------- 16 | 17 | 5 18 | 0 0 1 2 19 | 1 1 None None 20 | 2 2 3 4 21 | 3 3 None None 22 | 4 4 None None 23 | - 24 | True 25 | 26 | ----------- 27 | 28 | 2 29 | 0 0 None 1 30 | 1 1 None None 31 | - 32 | True -------------------------------------------------------------------------------- /yandex_practicum/sprint_5/tasks/B/image.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dmitryburov/algorithm-practice/1501896081a17ead0f3e5571f9f13cabaf889142/yandex_practicum/sprint_5/tasks/B/image.png -------------------------------------------------------------------------------- /yandex_practicum/sprint_5/tasks/B/task.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // Node 4 | // TODO Comment it before submitting 5 | type Node struct { 6 | value int 7 | left *Node 8 | right *Node 9 | } 10 | 11 | func Solution(root *Node) bool { 12 | if _, balanced := checkThree(root); !balanced { 13 | return false 14 | } 15 | 16 | return true 17 | } 18 | 19 | func checkThree(node *Node) (int, bool) { 20 | if node == nil { 21 | return 0, true 22 | } 23 | 24 | leftLen, leftStatus := checkThree(node.left) 25 | rightLen, rightStatus := checkThree(node.right) 26 | if !leftStatus || !rightStatus { 27 | return 0, false 28 | } 29 | 30 | res := leftLen - rightLen 31 | if res > 1 || res < -1 { 32 | return 0, false 33 | } 34 | 35 | if leftLen >= rightLen { 36 | return leftLen + 1, true 37 | } 38 | 39 | return rightLen + 1, true 40 | } 41 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_5/tasks/C/README.md: -------------------------------------------------------------------------------- 1 | # C. Дерево - анаграмма 2 | 3 | Гоша и Алла играют в игру «Удивительные деревья». Помогите ребятам определить, является ли дерево, которое им встретилось, деревом-анаграммой? 4 | 5 | Дерево называется анаграммой, если оно симметрично относительно своего центра. 6 | 7 | ![IMG](image.png) 8 | 9 | ## Формат ввода 10 | 11 | Напишите функцию, которая определяет, является ли дерево анаграммой. 12 | На вход подаётся корень дерева. 13 | 14 | Шаблон GO: 15 | 16 | ```go 17 | package main 18 | 19 | /** 20 | Comment it before submitting 21 | type Node struct { 22 | value int 23 | left *Node 24 | right *Node 25 | } 26 | **/ 27 | 28 | func Solution(root *Node) bool { 29 | // Your code 30 | // “ヽ(´▽｀)ノ” 31 | } 32 | ``` 33 | 34 | ## Формат вывода 35 | 36 | Функция должна вернуть True если дерево является анаграммой. Иначе - False. -------------------------------------------------------------------------------- /yandex_practicum/sprint_5/tasks/C/for tests.txt: -------------------------------------------------------------------------------- 1 | 7 2 | 0 1 1 2 3 | 1 2 3 4 4 | 2 2 5 6 5 | 3 3 None None 6 | 4 4 None None 7 | 5 4 None None 8 | 6 3 None None 9 | - 10 | True 11 | 12 | -------- 13 | 14 | 1 15 | 0 1 None None 16 | - 17 | True 18 | 19 | --------- 20 | 21 | 4 22 | 0 1 1 2 23 | 1 1 3 None 24 | 2 1 None None 25 | 3 1 None None 26 | - 27 | False 28 | 29 | ---------- 30 | 31 | 10 32 | 0 0 1 2 33 | 1 2 3 None 34 | 2 2 None 4 35 | 3 3 5 6 36 | 4 3 7 8 37 | 5 0 None None 38 | 6 1 None None 39 | 7 1 None None 40 | 8 0 None 9 41 | 9 0 None None 42 | - 43 | False -------------------------------------------------------------------------------- /yandex_practicum/sprint_5/tasks/C/image.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dmitryburov/algorithm-practice/1501896081a17ead0f3e5571f9f13cabaf889142/yandex_practicum/sprint_5/tasks/C/image.png -------------------------------------------------------------------------------- /yandex_practicum/sprint_5/tasks/C/task.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | ) 6 | 7 | // Node 8 | // TODO Comment it before submitting 9 | type Node struct { 10 | value int 11 | left *Node 12 | right *Node 13 | } 14 | 15 | func Solution(root *Node) bool { 16 | if root.left == nil && root.right == nil { 17 | return true 18 | } else if root.left == nil || root.right == nil { 19 | return false 20 | } 21 | 22 | return valueLR(root.left) == valueRL(root.right) 23 | } 24 | 25 | func valueLR(root *Node) string { 26 | if root == nil { 27 | return "" 28 | } 29 | return valueLR(root.left) + fmt.Sprint(root.value) + valueLR(root.right) 30 | } 31 | 32 | func valueRL(root *Node) string { 33 | if root == nil { 34 | return "" 35 | } 36 | return valueRL(root.right) + fmt.Sprint(root.value) + valueRL(root.left) 37 | } 38 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_5/tasks/D/README.md: -------------------------------------------------------------------------------- 1 | # D. Деревья - близнецы 2 | 3 | Гоше на день рождения подарили два дерева. Тимофей сказал, что они совершенно одинаковые. Но, по мнению Гоши, они отличаются. 4 | 5 | Помогите разрешить этот философский спор! 6 | 7 | ![IMG](image.png) 8 | 9 | ## Формат ввода 10 | 11 | На вход подаются корни двух деревьев. 12 | 13 | **Замечания про отправку решений** 14 | 15 | По умолчанию выбран компилятор make. 16 | Решение нужно отправлять в виде файла с расширением, которое соответствует вашему языку программирования. 17 | 18 | Go: 19 | 20 | ```go 21 | package main 22 | 23 | /** 24 | Comment it before submitting 25 | type Node struct { 26 | value int 27 | left *Node 28 | right *Node 29 | } 30 | **/ 31 | 32 | func Solution(root1 *Node, root2 *Node) bool { 33 | // Your code 34 | // “ヽ(´▽｀)ノ” 35 | } 36 | ``` 37 | 38 | ## Формат вывода 39 | 40 | Функция должна вернуть True если деревья являются близнецами. Иначе - False. -------------------------------------------------------------------------------- /yandex_practicum/sprint_5/tasks/D/image.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dmitryburov/algorithm-practice/1501896081a17ead0f3e5571f9f13cabaf889142/yandex_practicum/sprint_5/tasks/D/image.png -------------------------------------------------------------------------------- /yandex_practicum/sprint_5/tasks/E/README.md: -------------------------------------------------------------------------------- 1 | # E. Дерево поиска 2 | 3 | Гоша понял, что такое дерево поиска, и захотел написать функцию, которая определяет, является ли заданное дерево деревом поиска. Значения в левом поддереве должны быть строго меньше, в правом —- строго больше значения в узле. 4 | 5 | Помогите Гоше с реализацией этого алгоритма. 6 | 7 | ![IMG](image.png) 8 | 9 | ## Формат ввода 10 | 11 | На вход функции подается корень бинарного дерева. 12 | 13 | **Замечания про отправку решений** 14 | 15 | По умолчанию выбран компилятор make. 16 | Решение нужно отправлять в виде файла с расширением, которое соответствует вашему языку программирования. 17 | 18 | Go: 19 | 20 | ```go 21 | package main 22 | 23 | /** 24 | Comment it before submitting 25 | type Node struct { 26 | value int 27 | left *Node 28 | right *Node 29 | } 30 | **/ 31 | 32 | func Solution(root *Node) bool { 33 | // Your code 34 | // “ヽ(´▽｀)ノ” 35 | } 36 | ``` 37 | 38 | ## Формат вывода 39 | 40 | Функция должна вернуть True, если дерево является деревом поиска, иначе - False. 41 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_5/tasks/E/image.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dmitryburov/algorithm-practice/1501896081a17ead0f3e5571f9f13cabaf889142/yandex_practicum/sprint_5/tasks/E/image.png -------------------------------------------------------------------------------- /yandex_practicum/sprint_5/tasks/F/README.md: -------------------------------------------------------------------------------- 1 | # F. Максимальная глубина 2 | 3 | Алла хочет побывать на разных островах архипелага Алгосы. Она составила карту. Карта представлена в виде дерева: корень обозначает центр архипелага, узлы –— другие острова. А листья —– это дальние острова, на которые Алла хочет попасть. 4 | 5 | Помогите Алле определить максимальное число островов, через которые ей нужно пройти для совершения одной поездки от стартового острова до места назначения, включая начальный и конечный пункты. 6 | 7 | ![IMG](image.png) 8 | 9 | ## Формат ввода 10 | 11 | На вход подается корень дерева. 12 | 13 | **Замечания про отправку решений** 14 | 15 | По умолчанию выбран компилятор make. Шаблон для Go: 16 | 17 | ```go 18 | package main 19 | 20 | /** 21 | Comment it before submitting 22 | type Node struct { 23 | value int 24 | left *Node 25 | right *Node 26 | } 27 | **/ 28 | 29 | func Solution(root *Node) int { 30 | // Your code 31 | // “ヽ(´▽｀)ノ” 32 | } 33 | ``` 34 | 35 | 36 | 37 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_5/tasks/F/for tests.txt: -------------------------------------------------------------------------------- 1 | 12 2 | 0 5 1 2 3 | 1 3 3 4 4 | 2 8 5 6 5 | 3 1 None None 6 | 4 4 None None 7 | 5 6 None None 8 | 6 9 None 7 9 | 7 19 None 8 10 | 8 138 9 10 11 | 9 130 None None 12 | 10 140 11 None 13 | 11 139 None None 14 | - 15 | 7 16 | 17 | -------- 18 | 19 | 11 20 | 0 5 1 2 21 | 1 3 3 4 22 | 2 8 5 6 23 | 3 1 None None 24 | 4 4 None None 25 | 5 6 None None 26 | 6 9 None 7 27 | 7 19 None 8 28 | 8 138 9 10 29 | 9 130 None None 30 | 10 140 None None 31 | - 32 | 6 33 | 34 | --------- 35 | 36 | 1 37 | 0 1 None None 38 | - 39 | 1 40 | 41 | ---------- 42 | 43 | 8 44 | 0 1 None 1 45 | 1 1 None 2 46 | 2 2 None 3 47 | 3 2 None 4 48 | 4 2 None 5 49 | 5 2 6 None 50 | 6 2 7 None 51 | 7 2 None None 52 | - 53 | 8 -------------------------------------------------------------------------------- /yandex_practicum/sprint_5/tasks/F/image.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dmitryburov/algorithm-practice/1501896081a17ead0f3e5571f9f13cabaf889142/yandex_practicum/sprint_5/tasks/F/image.png -------------------------------------------------------------------------------- /yandex_practicum/sprint_5/tasks/F/task.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // Node 4 | // TODO Comment it before submitting 5 | type Node struct { 6 | value int 7 | left *Node 8 | right *Node 9 | } 10 | 11 | func Solution(root *Node) int { 12 | if root == nil { 13 | return 0 14 | } 15 | 16 | l := Solution(root.left) 17 | r := Solution(root.right) 18 | 19 | if l > r { 20 | return l + 1 21 | } 22 | 23 | return r + 1 24 | } 25 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_5/tasks/G/img.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dmitryburov/algorithm-practice/1501896081a17ead0f3e5571f9f13cabaf889142/yandex_practicum/sprint_5/tasks/G/img.png -------------------------------------------------------------------------------- /yandex_practicum/sprint_5/tasks/H/README.md: -------------------------------------------------------------------------------- 1 | # H. Числовые пути 2 | 3 | Вася и его друзья решили поиграть в игру. Дано дерево, в узлах которого записаны цифры от 0 до 9. Таким образом, каждый путь от корня до листа содержит число, получившееся конкатенацией цифр пути (склеиванием цифр пути в одно число). Нужно найти сумму всех таких чисел в дереве. 4 | 5 | Гарантируется, что ответ не превосходит 20 000. 6 | 7 | ![IMG](image.png) 8 | 9 | ## Формат ввода 10 | 11 | На вход подается корень дерева. 12 | 13 | 14 | **Замечания про отправку решений** 15 | 16 | По умолчанию выбран компилятор make. 17 | Решение нужно отправлять в виде файла с расширением, которое соответствует вашему языку программирования. 18 | 19 | Go: 20 | 21 | ```go 22 | package main 23 | 24 | /** 25 | Comment it before submitting 26 | type Node struct { 27 | value int 28 | left *Node 29 | right *Node 30 | } 31 | **/ 32 | 33 | func Solution(root *Node) int { 34 | // Your code 35 | // “ヽ(´▽｀)ノ” 36 | } 37 | ``` 38 | 39 | ## Формат вывода 40 | 41 | Функция должна вернуть число, равное сумме чисел всех путей в дереве. -------------------------------------------------------------------------------- /yandex_practicum/sprint_5/tasks/H/image.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dmitryburov/algorithm-practice/1501896081a17ead0f3e5571f9f13cabaf889142/yandex_practicum/sprint_5/tasks/H/image.png -------------------------------------------------------------------------------- /yandex_practicum/sprint_5/tasks/I/README.md: -------------------------------------------------------------------------------- 1 | # I. Разные деревья поиска 2 | 3 | Ребятам стало интересно, сколько может быть различных деревьев поиска, содержащих в своих узлах все уникальные числа от 1 до n. Помогите им найти ответ на этот вопрос. 4 | 5 | ## Формат ввода 6 | 7 | В единственной строке задано число n. Оно не превосходит 20. 8 | 9 | ## Формат вывода 10 | 11 | Нужно вывести число, равное количеству различных деревьев поиска, в узлах которых могут быть размещены числа от 1 до n включительно. 12 | 13 | ### Пример 1 14 | 15 | 16 | 17 | 18 |
22
19 | 20 | ### Пример 2 21 | 22 | 23 | 24 | 25 |
35
26 | 27 | ### Пример 3 28 | 29 | 30 | 31 | 32 |
414
-------------------------------------------------------------------------------- /yandex_practicum/sprint_5/tasks/J/README.md: -------------------------------------------------------------------------------- 1 | # J. Добавь узел 2 | 3 | Дано BST. Надо вставить узел с заданным ключом. Ключи в дереве могут повторяться. 4 | 5 | На вход функции подаётся корень корректного бинарного дерева поиска и ключ, который надо вставить в дерево. Осуществите вставку этого ключа. Если ключ уже есть в дереве, то его дубликаты уходят в правого сына. Таким образом вид дерева после вставки определяется однозначно. Функция должна вернуть корень дерева после вставки вершины. 6 | 7 | Ваше решение должно работать за O(h), где h –— высота дерева. На рисунках ниже даны два примера вставки вершин в дерево. 8 | 9 | ![IMG](image.png) 10 | 11 | ## Формат ввода 12 | 13 | Ключи дерева – натуральные числа, не превосходящие 109. Число вершин в дереве не превосходит 105. 14 | 15 | **Замечания про отправку решений ** 16 | 17 | По умолчанию выбран компилятор make. 18 | 19 | Шаблон для Go: 20 | 21 | ```go 22 | package main 23 | 24 | /** 25 | Comment it before submitting 26 | type Node struct { 27 | value int 28 | left *Node 29 | right *Node 30 | } 31 | **/ 32 | 33 | func insert(root *Node, key int) *Node { 34 | // Your code 35 | // “ヽ(´▽｀)ノ” 36 | } 37 | ``` 38 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_5/tasks/J/image.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dmitryburov/algorithm-practice/1501896081a17ead0f3e5571f9f13cabaf889142/yandex_practicum/sprint_5/tasks/J/image.png -------------------------------------------------------------------------------- /yandex_practicum/sprint_5/tasks/J/task.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // Node 4 | // TODO Comment it before submitting 5 | type Node struct { 6 | value int 7 | left *Node 8 | right *Node 9 | } 10 | 11 | func insert(root *Node, key int) *Node { 12 | if root.value <= key { 13 | if root.right == nil { 14 | root.right = &Node{value: key} 15 | } else { 16 | insert(root.right, key) 17 | } 18 | return root 19 | } else { 20 | if root.left == nil { 21 | root.left = &Node{value: key} 22 | } else { 23 | insert(root.left, key) 24 | } 25 | return root 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_5/tasks/K/for tests.txt: -------------------------------------------------------------------------------- 1 | correctness 2 | 5 3 | 1 7 2 4 4 | 2 3 3 -1 5 | 3 1 -1 -1 6 | 4 11 -1 5 7 | 5 15 -1 -1 8 | 6 9 | 14 10 | - 11 | 7 12 | 11 13 | 14 | ---------- 15 | 16 | correctness 17 | 8 18 | 1 4 2 5 19 | 2 3 3 4 20 | 3 1 -1 -1 21 | 4 4 -1 -1 22 | 5 5 6 7 23 | 6 4 -1 8 24 | 7 6 -1 -1 25 | 8 4 -1 -1 26 | 3 27 | 5 28 | - 29 | 3 30 | 4 31 | 4 32 | 4 33 | 4 34 | 5 35 | 36 | -------- 37 | 38 | correctness 39 | 10 40 | 1 31 -1 2 41 | 2 624 3 7 42 | 3 220 4 5 43 | 4 130 -1 -1 44 | 5 302 -1 6 45 | 6 442 -1 -1 46 | 7 858 8 10 47 | 8 763 9 -1 48 | 9 701 -1 -1 49 | 10 867 -1 -1 50 | 448 51 | 763 52 | - 53 | 624 54 | 701 55 | 763 56 | 57 | ---------- 58 | 59 | correctness 60 | 10 61 | 1 460 2 4 62 | 2 355 3 -1 63 | 3 270 -1 -1 64 | 4 818 5 10 65 | 5 649 6 9 66 | 6 626 7 -1 67 | 7 568 -1 8 68 | 8 609 -1 -1 69 | 9 708 -1 -1 70 | 10 840 -1 -1 71 | 208 72 | 301 73 | - 74 | 270 75 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_5/tasks/K/image.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dmitryburov/algorithm-practice/1501896081a17ead0f3e5571f9f13cabaf889142/yandex_practicum/sprint_5/tasks/K/image.png -------------------------------------------------------------------------------- /yandex_practicum/sprint_5/tasks/K/task.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | ) 6 | 7 | // Node 8 | // TODO Comment it before submitting 9 | type Node struct { 10 | value int 11 | left *Node 12 | right *Node 13 | } 14 | 15 | func printRange(root *Node, left int, right int) { 16 | if root == nil { 17 | return 18 | } 19 | 20 | if left <= root.value { 21 | printRange(root.left, left, right) 22 | } 23 | 24 | if left <= root.value && right >= root.value { 25 | fmt.Println(root.value) 26 | } 27 | 28 | if right >= root.value { 29 | printRange(root.right, left, right) 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_5/tasks/L/image.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dmitryburov/algorithm-practice/1501896081a17ead0f3e5571f9f13cabaf889142/yandex_practicum/sprint_5/tasks/L/image.png -------------------------------------------------------------------------------- /yandex_practicum/sprint_5/tasks/L/task.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func siftDown(heap []int, idx int) int { 4 | for { 5 | left := idx * 2 6 | right := idx*2 + 1 7 | 8 | if left >= len(heap) { 9 | break 10 | } 11 | 12 | max := 0 13 | 14 | if right < len(heap) && heap[right] > heap[left] { 15 | max = right 16 | } else { 17 | max = left 18 | } 19 | 20 | if heap[max] > heap[idx] { 21 | heap[max], heap[idx] = heap[idx], heap[max] 22 | idx = max 23 | } else { 24 | break 25 | } 26 | } 27 | 28 | return idx 29 | } 30 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_5/tasks/M/image.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dmitryburov/algorithm-practice/1501896081a17ead0f3e5571f9f13cabaf889142/yandex_practicum/sprint_5/tasks/M/image.png -------------------------------------------------------------------------------- /yandex_practicum/sprint_5/tasks/M/task.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func siftUp(heap []int, idx int) int { 4 | 5 | for heap[idx] > heap[idx/2] { 6 | if idx == 1 { 7 | break 8 | } 9 | 10 | heap[idx], heap[idx/2] = heap[idx/2], heap[idx] 11 | idx /= 2 12 | } 13 | 14 | return idx 15 | } 16 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_5/tasks/N/README.md: -------------------------------------------------------------------------------- 1 | # N. Разбиение дерева 2 | 3 | Дано бинарное дерево поиска, в котором хранятся целые числа. От этого дерева надо отделить k самых маленьких элементов. 4 | 5 | Реализуйте функцию, которая принимает корень дерева и число k , а возвращает два BST — в первом k наименьших элементов из исходного дерева, а во втором — оставшиеся вершины BST. 6 | 7 | В вершинах дерева уже записаны корректные размеры поддеревьев (точное название поля смотрите в заготовках кода). После разбиения размеры должны остаться корректными — вам придётся пересчитывать их на ходу. 8 | 9 | Ваше решение должно иметь асимптотику O(h), где h — высота исходного дерева. 10 | 11 | По умолчанию выбран компилятор make. 12 | 13 | Шаблон для Go: 14 | 15 | ```go 16 | package main 17 | 18 | /** 19 | Comment it before submitting 20 | type Node struct { 21 | value int 22 | left *Node 23 | right *Node 24 | size int 25 | } 26 | **/ 27 | 28 | func split(node *Node, k int) (*Node, *Node) { 29 | // Your code 30 | // “ヽ(´▽｀)ノ” 31 | } 32 | ``` 33 | 34 | ## Формат ввода 35 | 36 | Числа, записанные в вершинах дерева, лежат в диапазоне от 0 до 109. 37 | Дерево не содержит одинаковых ключей. Число вершин в дереве не превосходит 105. 38 | 39 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_5/tasks/N/for tests.txt: -------------------------------------------------------------------------------- 1 | correctness 2 | 10 3 | 1 668 2 5 4 | 2 298 3 -1 5 | 3 191 -1 4 6 | 4 266 -1 -1 7 | 5 702 6 7 8 | 6 701 -1 -1 9 | 7 870 8 9 10 | 8 822 -1 -1 11 | 9 912 -1 10 12 | 10 932 -1 -1 13 | 1 14 | 15 | -------- 16 | 17 | 18 | correctness 19 | 10 20 | 1 708 2 9 21 | 2 609 3 7 22 | 3 270 4 5 23 | 4 121 -1 -1 24 | 5 355 6 -1 25 | 6 322 -1 -1 26 | 7 671 8 -1 27 | 8 649 -1 -1 28 | 9 818 -1 10 29 | 10 840 -1 -1 30 | 4 31 | 32 | -------- 33 | 34 | correctness 35 | 10 36 | 1 867 2 -1 37 | 2 31 -1 3 38 | 3 545 4 8 39 | 4 220 5 6 40 | 5 130 -1 -1 41 | 6 302 -1 7 42 | 7 442 -1 -1 43 | 8 763 9 10 44 | 9 701 -1 -1 45 | 10 858 -1 -1 46 | 7 47 | 48 | --------- 49 | 50 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_5/tasks/N/task.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // Node 4 | // TODO закомментить перед отправкой 5 | type Node struct { 6 | value int 7 | left *Node 8 | right *Node 9 | size int 10 | } 11 | 12 | func split(node *Node, k int) (*Node, *Node) { 13 | if node == nil { 14 | return nil, nil 15 | } 16 | 17 | ls, rs := TreeSizes(node.left, node.right) 18 | 19 | if ls+1 > k { 20 | ln, rn := split(node.left, k) 21 | _, rnSize := TreeSizes(ln, rn) 22 | 23 | node.size = node.size - ls + rnSize 24 | node.left = rn 25 | 26 | return ln, node 27 | } 28 | 29 | ln, rn := split(node.right, k-(ls+1)) 30 | lnSize, _ := TreeSizes(ln, rn) 31 | 32 | node.size = node.size - rs + lnSize 33 | node.right = ln 34 | 35 | return node, rn 36 | } 37 | 38 | func TreeSizes(l, r *Node) (ls, rs int) { 39 | if l != nil { 40 | ls = l.size 41 | } 42 | if r != nil { 43 | rs = r.size 44 | } 45 | 46 | return 47 | } 48 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_6/final/A/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "strings" 7 | "testing" 8 | ) 9 | 10 | type TestItem struct { 11 | input io.Reader 12 | output string 13 | } 14 | 15 | func TestTask(t *testing.T) { 16 | tasks := generateTasks() 17 | 18 | for i, v := range tasks { 19 | t.Run(fmt.Sprintf("Test %d", i+1), func(t *testing.T) { 20 | buf := strings.Builder{} 21 | Solution(v.input, &buf) 22 | if buf.String() != v.output { 23 | t.Errorf("Неверный ответ решения!\nОтвет: \n%v \nВерно: \n%v", buf.String(), v.output) 24 | } 25 | }) 26 | } 27 | } 28 | 29 | func generateTasks() []TestItem { 30 | return []TestItem{ 31 | {strings.NewReader(`4 4 32 | 1 2 5 33 | 1 3 6 34 | 2 4 8 35 | 3 4 3 36 | `), "19"}, 37 | {strings.NewReader(`3 3 38 | 1 2 1 39 | 1 2 2 40 | 2 3 1 41 | `), "3"}, 42 | {strings.NewReader(`2 0 43 | `), "Oops! I did it again"}, 44 | {strings.NewReader(`1 0 45 | `), "0"}, 46 | {strings.NewReader(`10 20 47 | 9 10 4 48 | 2 2 4 49 | 4 2 8 50 | 10 5 3 51 | 1 10 6 52 | 7 4 2 53 | 10 10 6 54 | 3 7 4 55 | 8 9 4 56 | 8 10 7 57 | 6 10 10 58 | 2 8 8 59 | 3 8 1 60 | 3 10 3 61 | 9 5 8 62 | 10 10 2 63 | 1 8 1 64 | 10 1 5 65 | 3 6 10 66 | 9 10 8 67 | `), "69"}} 68 | } 69 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_6/final/B/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "strings" 7 | "testing" 8 | ) 9 | 10 | type TestItem struct { 11 | input io.Reader 12 | output string 13 | } 14 | 15 | func TestTask(t *testing.T) { 16 | tasks := generateTasks() 17 | 18 | for i, v := range tasks { 19 | t.Run(fmt.Sprintf("Test %d", i+1), func(t *testing.T) { 20 | buf := strings.Builder{} 21 | Solution(v.input, &buf) 22 | if buf.String() != v.output { 23 | t.Errorf("Неверный ответ решения!\nОтвет: \n%v \nВерно: \n%v", buf.String(), v.output) 24 | } 25 | }) 26 | } 27 | } 28 | 29 | func generateTasks() []TestItem { 30 | return []TestItem{{strings.NewReader(`3 31 | RB 32 | R 33 | `), "NO"}, {strings.NewReader(`4 34 | BBB 35 | RB 36 | B 37 | `), "YES"}, {strings.NewReader(`5 38 | RRRB 39 | BRR 40 | BR 41 | R 42 | `), "NO"}, {strings.NewReader(`10 43 | RRBBRRBRR 44 | RRBBBBRR 45 | RRBRRRB 46 | RRRRBR 47 | BBBBB 48 | RRBB 49 | BBR 50 | RB 51 | B 52 | `), "NO"}} 53 | } 54 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_6/tasks/A/README.md: -------------------------------------------------------------------------------- 1 | # A. Построить список смежности 2 | 3 | Алла пошла на стажировку в студию графического дизайна, где ей дали такое задание: для очень большого числа ориентированных графов преобразовать их список рёбер в список смежности. Чтобы побыстрее решить эту задачу, она решила автоматизировать процесс. 4 | 5 | Помогите Алле написать программу, которая по списку рёбер графа будет строить его список смежности. 6 | 7 | ## Формат ввода 8 | 9 | В первой строке дано число вершин n (1 ≤ n ≤ 100) и число ребер m (1 ≤ m ≤ n(n-1)). 10 | В следующих m строках заданы ребра в виде пар вершин (u,v), если ребро ведет от u к v. 11 | 12 | ## Формат вывода 13 | 14 | Выведите информацию о рёбрах, исходящих из каждой вершины.
15 | В строке i надо написать число рёбер, исходящих из вершины i, а затем перечислить вершины, в которые ведут эти рёбра –— в порядке возрастания их номеров. 16 | 17 | ### Пример 18 | 19 | 20 | 27 | 34 |
21 | 5 3
22 | 1 3
23 | 2 3
24 | 5 2
25 |
26 | 		28 | 1 3
29 | 1 3
30 | 0
31 | 0
32 | 1 2 33 |
35 | 36 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_6/tasks/B/README.md: -------------------------------------------------------------------------------- 1 | # B. Перевести список ребер в матрицу смежности 2 | 3 | Алла успешно справилась с предыдущим заданием, и теперь ей дали новое. На этот раз список рёбер ориентированного графа надо переводить в матрицу смежности. Конечно же, Алла попросила вас помочь написать программу для этого. 4 | 5 | ## Формат ввода 6 | 7 | В первой строке дано число вершин n (1 ≤ n ≤ 100) и число рёбер m (1 ≤ m ≤ n(n-1)). В следующих m строках заданы ребра в виде пар вершин (u,v), если ребро ведет от u к v. 8 | 9 | ## Формат вывода 10 | 11 | Выведите матрицу смежности n на n. На пересечении i-й строки и j-го столбца стоит единица, если есть ребро, ведущее из i в j. 12 | 13 | ### Пример 14 | 15 | 16 | 23 | 30 |
17 | 5 3
18 | 1 3
19 | 2 3
20 | 5 2
21 |
22 | 		24 | 0 0 1 0 0
25 | 0 0 1 0 0
26 | 0 0 0 0 0
27 | 0 0 0 0 0
28 | 0 1 0 0 0 29 |
31 | 32 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_6/tasks/B/task.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bufio" 5 | "fmt" 6 | "io" 7 | "os" 8 | "strconv" 9 | "strings" 10 | ) 11 | 12 | type Matrix [][]int 13 | 14 | func main() { 15 | s := strings.Builder{} 16 | Solution(os.Stdin, &s) 17 | 18 | fmt.Println(s.String()) 19 | } 20 | 21 | func Solution(r io.Reader, s *strings.Builder) { 22 | scanner := bufio.NewScanner(r) 23 | scanner.Scan() 24 | 25 | nValues := strings.Fields(scanner.Text()) 26 | n, _ := strconv.Atoi(nValues[0]) 27 | m, _ := strconv.Atoi(nValues[1]) 28 | 29 | matrix := make(Matrix, n) 30 | for i := 0; i < m; i++ { 31 | scanner.Scan() 32 | edge := strings.Fields(scanner.Text()) 33 | edgeA, _ := strconv.Atoi(edge[0]) 34 | edgeB, _ := strconv.Atoi(edge[1]) 35 | edgeA-- 36 | edgeB-- 37 | if matrix[edgeA] == nil { 38 | matrix[edgeA] = make([]int, n) 39 | } 40 | matrix[edgeA][edgeB] = 1 41 | } 42 | for _, v := range matrix { 43 | if v == nil { 44 | v = make([]int, n) 45 | } 46 | for _, vV := range v { 47 | s.WriteString(fmt.Sprint(vV) + " ") 48 | } 49 | s.WriteString("\n") 50 | } 51 | } 52 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_6/tasks/C/README.md: -------------------------------------------------------------------------------- 1 | # C. DFS 2 | 3 | Задан неориентированный граф. Обойдите с помощью DFS все вершины, достижимые из заданной вершины s, и выведите их в порядке обхода, если начинать обход из s. 4 | 5 | ## Формат ввода 6 | 7 | В первой строке дано количество вершин n (1 ≤ n ≤ 105) и рёбер m (0 ≤ m ≤ 105). Далее в m строках описаны рёбра графа. Каждое ребро описывается номерами двух вершин u и v (1 ≤ u, v ≤ n). В последней строке дан номер стартовой вершины s (1 ≤ s ≤ n). 8 | В графе нет петель и кратных рёбер. 9 | 10 | ## Формат вывода 11 | 12 | Выведите вершины в порядке обхода, считая что при запуске от каждой конкретной вершины её соседи будут рассматриваться в порядке возрастания (то есть если вершина 2 соединена с 1 и 3, то сначала обход пойдёт в 1, а уже потом в 3). 13 | 14 | ### Пример 1 15 | 16 | 17 | 25 | 33 |
18 | 4 4
19 | 3 2
20 | 4 3
21 | 1 4
22 | 1 2
23 | 3 24 | 		26 | 3 2 1 4
27 |
28 |
29 |
30 |
31 |
32 |
34 | 35 | ### Пример 2 36 | 37 | 38 | 43 | 48 |
39 | 2 1
40 | 1 2
41 | 1 42 | 		44 | 1 2
45 |
46 |
47 |
49 | 50 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_6/tasks/C/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "strings" 7 | "testing" 8 | ) 9 | 10 | type TestItem struct { 11 | input io.Reader 12 | output string 13 | } 14 | 15 | func TestTask(t *testing.T) { 16 | tasks := generateTasks() 17 | 18 | for i, v := range tasks { 19 | t.Run(fmt.Sprintf("Test %d", i+1), func(t *testing.T) { 20 | buf := strings.Builder{} 21 | Solution(v.input, &buf) 22 | if strings.TrimSpace(buf.String()) != v.output { 23 | t.Errorf("Неверный ответ решения!\nОтвет: \n%v \nВерно: \n%v", buf.String(), v.output) 24 | } 25 | }) 26 | } 27 | } 28 | 29 | func generateTasks() []TestItem { 30 | return []TestItem{ 31 | {strings.NewReader(`4 4 32 | 3 2 33 | 4 3 34 | 1 4 35 | 1 2 36 | 3 37 | `), "3 2 1 4"}, 38 | {strings.NewReader(`2 1 39 | 1 2 40 | 1 41 | `), "1 2"}, 42 | {strings.NewReader(`1 0 43 | 1 44 | `), "1"}, 45 | {strings.NewReader(`6 7 46 | 3 2 47 | 5 4 48 | 3 1 49 | 1 4 50 | 1 6 51 | 1 2 52 | 1 5 53 | 1 54 | `), "1 2 3 4 5 6"}, 55 | {strings.NewReader(`10 13 56 | 9 2 57 | 1 3 58 | 6 10 59 | 5 10 60 | 9 10 61 | 5 9 62 | 3 5 63 | 5 2 64 | 6 7 65 | 5 6 66 | 8 3 67 | 6 1 68 | 4 2 69 | 7 70 | `), "7 6 1 3 5 2 4 9 10 8"}, 71 | } 72 | } 73 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_6/tasks/D/README.md: -------------------------------------------------------------------------------- 1 | # D. BFS 2 | 3 | Задан неориентированный граф. Обойдите поиском в ширину все вершины, достижимые из заданной вершины s, и выведите их в порядке обхода, если начинать обход из s. 4 | 5 | ## Формат ввода 6 | 7 | В первой строке дано количество вершин n (1 ≤ n ≤ 105) и рёбер m (0 ≤ m ≤ 105). Далее в m строках описаны рёбра графа. Каждое ребро описывается номерами двух вершин u и v (1 ≤ u, v ≤ n). 8 | В последней строке дан номер стартовой вершины s (1 ≤ s ≤ n). 9 | 10 | Гарантируется, что в графе нет петель и кратных рёбер. 11 | 12 | ## Формат вывода 13 | 14 | Выведите вершины в порядке обхода, считая что при запуске от каждой конкретной вершины её соседи будут рассматриваться в порядке возрастания (то есть если вершина 2 соединена с 1 и 3, то сначала обход пойдёт в 1, а уже потом в 3). 15 | 16 | ### Пример 1 17 | 18 | 19 | 27 | 35 |
20 | 4 4
21 | 1 2
22 | 2 3
23 | 3 4
24 | 1 4
25 | 3 26 | 		28 | 3 2 4 1
29 |
30 |
31 |
32 |
33 |
34 |
36 | 37 | 38 | ### Пример 2 39 | 40 | 41 | 46 | 51 |
42 | 2 1
43 | 2 1
44 | 1 45 | 		47 | 1 2
48 |
49 |
50 |
52 | 53 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_6/tasks/D/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "strings" 7 | "testing" 8 | ) 9 | 10 | type TestItem struct { 11 | input io.Reader 12 | output string 13 | } 14 | 15 | func TestTask(t *testing.T) { 16 | tasks := generateTasks() 17 | 18 | for i, v := range tasks { 19 | t.Run(fmt.Sprintf("Test %d", i+1), func(t *testing.T) { 20 | buf := strings.Builder{} 21 | Solution(v.input, &buf) 22 | if strings.TrimSpace(buf.String()) != v.output { 23 | t.Errorf("Неверный ответ решения!\nОтвет: \n%v \nВерно: \n%v", buf.String(), v.output) 24 | } 25 | }) 26 | } 27 | } 28 | 29 | func generateTasks() []TestItem { 30 | return []TestItem{ 31 | {strings.NewReader(`4 4 32 | 1 2 33 | 2 3 34 | 3 4 35 | 1 4 36 | 3 37 | `), "3 2 4 1"}, 38 | {strings.NewReader(`2 1 39 | 1 2 40 | 1 41 | `), "1 2"}, 42 | {strings.NewReader(`1 0 43 | 1 44 | `), "1"}, 45 | {strings.NewReader(`6 7 46 | 3 2 47 | 5 4 48 | 3 1 49 | 1 4 50 | 1 6 51 | 1 2 52 | 1 5 53 | 1 54 | `), "1 2 3 4 5 6"}, 55 | {strings.NewReader(`6 8 56 | 5 6 57 | 1 4 58 | 2 5 59 | 2 4 60 | 6 4 61 | 5 4 62 | 1 5 63 | 3 1 64 | 1 65 | `), "1 3 4 5 2 6"}, 66 | } 67 | } 68 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_6/tasks/E/README.md: -------------------------------------------------------------------------------- 1 | # E. Компоненты связности 2 | 3 | Вам дан неориентированный граф. Найдите его компоненты связности. 4 | 5 | ## Формат ввода 6 | 7 | В первой строке дано количество вершин n (1≤ n ≤ 105) и рёбер m (0 ≤ m ≤ 2 ⋅ 105). В каждой из следующих m строк записано по ребру в виде пары вершин 1 ≤ u, v ≤ n. 8 | 9 | Гарантируется, что в графе нет петель и кратных рёбер. 10 | 11 | ## Формат вывода 12 | 13 | Выведите все компоненты связности в следующем формате: в первой строке выведите общее количество компонент. 14 | 15 | Затем на отдельных строках выведите вершины каждой компоненты, отсортированные по возрастанию номеров. Компоненты между собой упорядочивайте по номеру первой вершины. 16 | 17 | ### Пример 1 18 | 19 | 20 | 26 | 32 |
21 | 6 3
22 | 1 2
23 | 6 5
24 | 2 3 25 | 		27 | 3
28 | 1 2 3
29 | 4
30 | 5 6 31 |
33 | 34 | ### Пример 2 35 | 36 | 37 | 42 | 47 |
38 | 2 0
39 |
40 |
41 | 		43 | 2
44 | 1
45 | 2 46 |
48 | 49 | ### Пример 3 50 | 51 | 52 | 58 | 64 |
53 | 4 3
54 | 2 3
55 | 2 1
56 | 4 3 57 | 		59 | 1
60 | 1 2 3 4
61 |
62 |
63 |
65 | 66 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_6/tasks/E/task.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_6/tasks/E/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_6/tasks/F/README.md: -------------------------------------------------------------------------------- 1 | # F. Расстояние между вершинами 2 | 3 | Найдите кратчайшее расстояние между парой вершин в неориентированном графе. Граф может быть несвязным. 4 | 5 | ## Формат ввода 6 | 7 | В первой строке дано количество вершин n (1 ≤ n ≤ 105) и рёбер m (1 ≤ m ≤ 105). 8 | Далее в m строках описаны рёбра графа. Каждое ребро описывается номерами двух вершин u и v (1 ≤ u, v ≤ n). В последней строке дан номер стартовой вершины s (1 ≤ s ≤ n) и конечной t (1 ≤ t ≤ n). 9 | 10 | Гарантируется, что в графе нет петель и кратных рёбер. 11 | 12 | ## Формат вывода 13 | 14 | Выведите длину кратчайшего пути (в рёбрах) между заданной парой вершин. Если пути не существует, то выведите -1. 15 | 16 | ### Пример 1 17 | 18 | 19 | 28 | 37 |
20 | 5 5
21 | 2 4
22 | 3 5
23 | 2 1
24 | 2 3
25 | 4 5
26 | 1 5 27 | 		29 | 3
30 |
31 |
32 |
33 |
34 |
35 |
36 |
38 | 39 | ### Пример 2 40 | 41 | 42 | 49 | 56 |
43 | 4 3
44 | 2 3
45 | 4 3
46 | 2 4
47 | 1 3 48 | 		50 | -1
51 |
52 |
53 |
54 |
55 |
57 | 58 | ### Пример 3 59 | 60 | 61 | 66 | 71 |
62 | 2 1
63 | 2 1
64 | 1 1 65 | 		67 | 0
68 |
69 |
70 |
72 | 73 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_6/tasks/F/task.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_6/tasks/F/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_6/tasks/G/task.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_6/tasks/G/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_6/tasks/H/README.md: -------------------------------------------------------------------------------- 1 | # H. Время выходить 2 | 3 | Вам дан ориентированный граф. Известно, что все его вершины достижимы из вершины s=1. Найдите время входа и выхода при обходе в глубину, производя первый запуск из вершины s. Считайте, что время входа в стартовую вершину равно 0. Соседей каждой вершины обходите в порядке увеличения номеров. 4 | 5 | ## Формат ввода 6 | 7 | В первой строке дано число вершин n (1 ≤ n ≤ 2⋅ 105) и рёбер (0 ≤ m ≤ 2 ⋅ 105). 8 | В каждой из следующих m строк записаны рёбра графа в виде пар (from, to), 1 ≤ from ≤ n — начало ребра, 1 ≤ to ≤ n — его конец. Гарантируется, что в графе нет петель и кратных рёбер. 9 | 10 | ## Формат вывода 11 | 12 | Выведите n строк, в каждой из которых записана пара чисел tini, touti — время входа и выхода для вершины i. 13 | 14 | ### Пример 1 15 | 16 | 17 | 28 | 36 |
18 | 6 8
19 | 2 6
20 | 1 6
21 | 3 1
22 | 2 5
23 | 4 3
24 | 3 2
25 | 1 2
26 | 1 4 27 | 		29 | 0 11
30 | 1 6
31 | 8 9
32 | 7 10
33 | 2 3
34 | 4 5 35 |
37 | 38 | ### Пример 2 39 | 40 | 41 | 46 | 51 |
42 | 3 2
43 | 1 2
44 | 2 3 45 | 		47 | 0 5
48 | 1 4
49 | 2 3 50 |
52 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_6/tasks/H/task.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_6/tasks/H/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_6/tasks/J/README.md: -------------------------------------------------------------------------------- 1 | # J. Топологическая сортировка 2 | 3 | Дан ациклический ориентированный граф (так называемый DAG, directed acyclic graph). Найдите его топологическую сортировку, то есть выведите его вершины в таком порядке, что все рёбра графа идут слева направо. У графа может быть несколько подходящих перестановок вершин. Вам надо найти любую топологическую сортировку. 4 | 5 | ## Формат ввода 6 | 7 | В первой строке даны два числа – количество вершин n (1 ≤ n ≤ 105) и количество рёбер m (0 ≤ m ≤ 105). В каждой из следующих m строк описаны рёбра по одному на строке. 8 | Каждое ребро представлено парой вершин (from, to), 1≤ from, to ≤ n, соответственно номерами вершин начала и конца. 9 | 10 | ## Формат вывода 11 | 12 | Выведите номера вершин в требуемом порядке. 13 | 14 | ### Пример 1 15 | 16 | 17 | 23 | 29 |
18 | 5 3
19 | 3 2
20 | 3 4
21 | 2 5 22 | 		24 | 1 3 2 4 5
25 |
26 |
27 |
28 |
30 | 31 | ### Пример 2 32 | 33 | 34 | 40 | 46 |
35 | 6 3
36 | 6 4
37 | 4 1
38 | 5 1 39 | 		41 | 2 3 5 6 4 1
42 |
43 |
44 |
45 |
47 | 48 | ### Пример 3 49 | 50 | 51 | 54 | 57 |
52 | 4 0 53 | 55 | 1 2 3 4 56 |
58 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_6/tasks/J/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "strings" 7 | "testing" 8 | ) 9 | 10 | type TestItem struct { 11 | input io.Reader 12 | output string 13 | } 14 | 15 | func TestTask(t *testing.T) { 16 | tasks := generateTasks() 17 | 18 | for i, v := range tasks { 19 | t.Run(fmt.Sprintf("Test %d", i+1), func(t *testing.T) { 20 | buf := strings.Builder{} 21 | Solution(v.input, &buf) 22 | if buf.String() != v.output { 23 | t.Errorf("Неверный ответ решения!\nОтвет: \n%v \nВерно: \n%v", buf.String(), v.output) 24 | } 25 | }) 26 | } 27 | } 28 | 29 | func generateTasks() []TestItem { 30 | return []TestItem{ 31 | {strings.NewReader(`5 3 32 | 3 2 33 | 3 4 34 | 2 5 35 | `), "1 3 2 4 5"}, 36 | {strings.NewReader(`6 3 37 | 6 4 38 | 4 1 39 | 5 1 40 | `), "2 3 5 6 4 1"}, 41 | {strings.NewReader(`4 0 42 | `), "1 2 3 4"}, 43 | } 44 | } 45 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_6/tasks/K/task.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_6/tasks/K/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_6/tasks/L/README.md: -------------------------------------------------------------------------------- 1 | # L. Полный граф 2 | 3 | Неориентированный граф называется полным, если в нём каждая пара вершин соединена ребром. 4 | 5 | Вам дан неориентированный граф из n вершин и m рёбер. Выясните, является ли этот граф полным. 6 | 7 | ## Формат ввода 8 | 9 | В первой строке дано число вершин n (1 ≤ n ≤ 105) и число рёбер m (0 ≤ m ≤ 5 ⋅ 105). В следующих m строках записаны рёбра в виде пар вершин u и v (1 ≤ u, v ≤ n). 10 | 11 | ## Формат вывода 12 | 13 | Если граф является полным, выведите «YES», иначе выведите «NO». 14 | 15 | ### Пример 1 16 | 17 | 18 | 27 | 36 |
19 | 4 6
20 | 1 2
21 | 2 2
22 | 2 3
23 | 2 4
24 | 3 4
25 | 4 3 26 | 		28 | NO
29 |
30 |
31 |
32 |
33 |
34 |
35 |
37 | 38 | ### Пример 2 39 | 40 | 41 | 49 | 57 |
42 | 3 5
43 | 1 2
44 | 2 1
45 | 3 1
46 | 2 3
47 | 3 3 48 | 		50 | YES
51 |
52 |
53 |
54 |
55 |
56 |
58 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_6/tasks/L/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "strings" 7 | "testing" 8 | ) 9 | 10 | type TestItem struct { 11 | input io.Reader 12 | output string 13 | } 14 | 15 | func TestTask(t *testing.T) { 16 | tasks := generateTasks() 17 | 18 | for i, v := range tasks { 19 | t.Run(fmt.Sprintf("Test %d", i+1), func(t *testing.T) { 20 | buf := strings.Builder{} 21 | Solution(v.input, &buf) 22 | if buf.String() != v.output { 23 | t.Errorf("Неверный ответ решения!\nОтвет: \n%v \nВерно: \n%v", buf.String(), v.output) 24 | } 25 | }) 26 | } 27 | } 28 | 29 | func generateTasks() []TestItem { 30 | return []TestItem{ 31 | {strings.NewReader(`4 6 32 | 1 2 33 | 2 2 34 | 2 3 35 | 2 4 36 | 3 4 37 | 4 3 38 | `), "NO"}, 39 | {strings.NewReader(`3 5 40 | 1 2 41 | 2 1 42 | 3 1 43 | 2 3 44 | 3 3 45 | `), "YES"}, 46 | } 47 | } 48 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_6/tasks/M/img.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dmitryburov/algorithm-practice/1501896081a17ead0f3e5571f9f13cabaf889142/yandex_practicum/sprint_6/tasks/M/img.png -------------------------------------------------------------------------------- /yandex_practicum/sprint_6/tasks/M/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "strings" 7 | "testing" 8 | ) 9 | 10 | type TestItem struct { 11 | input io.Reader 12 | output string 13 | } 14 | 15 | func TestTask(t *testing.T) { 16 | tasks := generateTasks() 17 | 18 | for i, v := range tasks { 19 | t.Run(fmt.Sprintf("Test %d", i+1), func(t *testing.T) { 20 | buf := strings.Builder{} 21 | Solution(v.input, &buf) 22 | if strings.TrimSpace(buf.String()) != v.output { 23 | t.Errorf("Неверный ответ решения!\nОтвет: \n%v \nВерно: \n%v", buf.String(), v.output) 24 | } 25 | }) 26 | } 27 | } 28 | 29 | func generateTasks() []TestItem { 30 | return []TestItem{ 31 | {strings.NewReader(`3 2 32 | 1 2 33 | 2 3 34 | `), SUCCESS}, 35 | {strings.NewReader(`3 3 36 | 1 2 37 | 2 3 38 | 1 3 39 | `), FAIL}, 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_7/final/A/README.md: -------------------------------------------------------------------------------- 1 | # A. Расстояние по Левенштейну 2 | 3 | Расстоянием Левенштейна между двумя строками s и t называется количество атомарных изменений, с помощью которых можно одну строку превратить в другую. Под атомарными изменениями подразумеваются: удаление одного символа, вставка одного символа, замена одного символа на другой. 4 | 5 | Найдите расстояние Левенштейна для предложенной пары строк. 6 | 7 | ## Формат ввода 8 | 9 | В первой строке дана строка s, во второй — строка t. Длины обеих строк не превосходят 1000. Строки состоят из маленьких латинских букв. 10 | 11 | ## Формат вывода 12 | 13 | Выведите единственное число — расстояние между строками. 14 | 15 | ### Пример 1 16 | 17 | 18 | 22 | 26 |
19 | abacaba
20 | abaabc 21 | 		23 | 2
24 |
25 |
27 | 28 | ### Пример 2 29 | 30 | 31 | 35 | 39 |
32 | innokentiy
33 | innnokkentia 34 | 		36 | 3
37 |
38 |
40 | 41 | ### Пример 3 42 | 43 | 44 | 48 | 52 |
45 | r
46 | x 47 | 		49 | 1
50 |
51 |
53 | 54 | 55 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_7/final/A/task.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bufio" 5 | "bytes" 6 | "fmt" 7 | "io" 8 | "os" 9 | "strings" 10 | ) 11 | 12 | func main() { 13 | s := strings.Builder{} 14 | Solution(os.Stdin, &s) 15 | 16 | fmt.Println(s.String()) 17 | } 18 | 19 | // Solution решение задачи 20 | func Solution(r io.Reader, w *strings.Builder) { 21 | scanner := bufio.NewScanner(r) 22 | 23 | // считаем строки в байты (!) 24 | scanner.Scan() 25 | s := scanner.Bytes() 26 | scanner.Scan() 27 | t := scanner.Bytes() 28 | 29 | lenS, lenT := len(s), len(t) 30 | 31 | // fix базовый случай 32 | if bytes.Equal(s, t) { 33 | w.WriteString("0") 34 | return 35 | } 36 | 37 | matrix := make([]int, lenS+1) 38 | for i := 1; i < len(matrix); i++ { 39 | matrix[i] = i 40 | } 41 | 42 | for i := 1; i <= lenT; i++ { 43 | prev := i 44 | for j := 1; j <= lenS; j++ { 45 | if t[i-1] != s[j-1] { 46 | matrix[j-1] = getMinimum(matrix[j]+1, getMinimum(matrix[j-1]+1, prev+1)) 47 | } 48 | matrix[j-1], prev = prev, matrix[j-1] 49 | } 50 | matrix[lenS] = prev 51 | } 52 | 53 | // результат 54 | w.WriteString(fmt.Sprint(matrix[lenS])) 55 | } 56 | 57 | // getMinimum сравнение минимального числа 58 | func getMinimum(a, b int) int { 59 | if a < b { 60 | return a 61 | } 62 | return b 63 | } 64 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_7/final/A/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "strings" 7 | "testing" 8 | ) 9 | 10 | type TestItem struct { 11 | input io.Reader 12 | output string 13 | } 14 | 15 | func TestTask(t *testing.T) { 16 | tasks := generateTasks() 17 | 18 | for i, v := range tasks { 19 | t.Run(fmt.Sprintf("Test %d", i+1), func(t *testing.T) { 20 | buf := strings.Builder{} 21 | Solution(v.input, &buf) 22 | if buf.String() != v.output { 23 | t.Errorf("Неверный ответ решения!\nОтвет: \n%v \nВерно: \n%v", buf.String(), v.output) 24 | } 25 | }) 26 | } 27 | } 28 | 29 | func generateTasks() []TestItem { 30 | return []TestItem{ 31 | {strings.NewReader(`abacaba 32 | abaabc 33 | `), "2"}, 34 | {strings.NewReader(`innokentiy 35 | innnokkentia 36 | `), "3"}, 37 | {strings.NewReader(`r 38 | x 39 | `), "1"}, 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_7/final/B/README.md: -------------------------------------------------------------------------------- 1 | # B. Одинаковые суммы 2 | 3 | На Алгосах устроили турнир по настольному теннису. Гоша выиграл n партий, получив при этом некоторое количество очков за каждую из них. 4 | 5 | Гоше стало интересно, можно ли разбить все заработанные им во время турнира очки на две части так, чтобы сумма в них была одинаковой. 6 | 7 | ## Формат ввода 8 | 9 | В первой строке записано целое число n (0 ≤ n ≤ 300) –— количество выигранных партий. 10 | 11 | Во второй строке через пробел записано n целых неотрицательных чисел, каждое из которых не превосходит 300 –— заработанные в партиях очки. 12 | 13 | ## Формат вывода 14 | 15 | Нужно вывести True, если произвести такое разбиение возможно, иначе —– False 16 | 17 | ### Пример 1 18 | 19 | 20 | 24 | 28 |
21 | 4
22 | 1 5 7 1 23 | 		25 | True
26 |
27 |
29 | 30 | ### Пример 2 31 | 32 | 33 | 37 | 41 |
34 | 3
35 | 2 10 9 36 | 		38 | False
39 |
40 |
-------------------------------------------------------------------------------- /yandex_practicum/sprint_7/final/B/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "strings" 7 | "testing" 8 | ) 9 | 10 | type TestItem struct { 11 | input io.Reader 12 | output string 13 | } 14 | 15 | func TestTask(t *testing.T) { 16 | tasks := generateTasks() 17 | 18 | for i, v := range tasks { 19 | t.Run(fmt.Sprintf("Test %d", i+1), func(t *testing.T) { 20 | buf := strings.Builder{} 21 | Solution(v.input, &buf) 22 | if buf.String() != v.output { 23 | t.Errorf("Неверный ответ решения!\nОтвет: \n%v \nВерно: \n%v", buf.String(), v.output) 24 | } 25 | }) 26 | } 27 | } 28 | 29 | func generateTasks() []TestItem { 30 | return []TestItem{ 31 | {strings.NewReader(`4 32 | 1 5 7 1 33 | `), "True"}, 34 | {strings.NewReader(`3 35 | 2 10 9 36 | `), "False"}, 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_7/tasks/A/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "strings" 7 | "testing" 8 | ) 9 | 10 | type TestItem struct { 11 | input io.Reader 12 | output string 13 | } 14 | 15 | func TestTask(t *testing.T) { 16 | tasks := generateTasks() 17 | 18 | for i, v := range tasks { 19 | t.Run(fmt.Sprintf("Test %d", i+1), func(t *testing.T) { 20 | buf := strings.Builder{} 21 | Solution(v.input, &buf) 22 | if buf.String() != v.output { 23 | t.Errorf("Неверный ответ решения!\nОтвет: \n%v \nВерно: \n%v", buf.String(), v.output) 24 | } 25 | }) 26 | } 27 | } 28 | 29 | func generateTasks() []TestItem { 30 | return []TestItem{ 31 | {strings.NewReader(`6 32 | 7 1 5 3 6 4 33 | `), "7"}, 34 | {strings.NewReader(`5 35 | 1 2 3 4 5 36 | `), "4"}, 37 | {strings.NewReader(`6 38 | 1 12 12 16 1 8 39 | `), "22"}, 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_7/tasks/C/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "strings" 7 | "testing" 8 | ) 9 | 10 | type TestItem struct { 11 | input io.Reader 12 | output string 13 | } 14 | 15 | func TestTask(t *testing.T) { 16 | tasks := generateTasks() 17 | 18 | for i, v := range tasks { 19 | t.Run(fmt.Sprintf("Test %d", i+1), func(t *testing.T) { 20 | buf := strings.Builder{} 21 | Solution(v.input, &buf) 22 | if buf.String() != v.output { 23 | t.Errorf("Неверный ответ решения!\nОтвет: \n%v \nВерно: \n%v", buf.String(), v.output) 24 | } 25 | }) 26 | } 27 | } 28 | 29 | func generateTasks() []TestItem { 30 | return []TestItem{ 31 | {strings.NewReader(`10 32 | 3 33 | 8 1 34 | 2 10 35 | 4 5 36 | `), "36"}, 37 | {strings.NewReader(`10000 38 | 1 39 | 4 20 40 | `), "80"}, 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_7/tasks/D/README.md: -------------------------------------------------------------------------------- 1 | # D. Числа Фибоначчи для взрослых 2 | 3 | Гоша практикуется в динамическом программировании — он хочет быстро считать числа Фибоначчи. 4 | 5 | Напомним, что числа Фибоначчи определены как последовательность Fn, n = 0,1. F0 = F1 = 1, Fn = Fn-1 + Fn-2, n ≥ 2. 6 | 7 | Помогите Гоше решить эту задачу 8 | 9 | ## Формат ввода 10 | 11 | В единственной строке дано целое число n (0 ≤ n ≤ 106). 12 | 13 | ## Формат вывода 14 | 15 | Вычислите значение Fn по модулю 109 + 7 и выведите его. 16 | 17 | ### Пример 1 18 | 19 | 20 | 23 | 26 |
21 | 5 22 | 24 | 8 25 |
27 | 28 | ### Пример 2 29 | 30 | 31 | 34 | 37 |
32 | 2 33 | 35 | 2 36 |
38 | 39 | ### Пример 3 40 | 41 | 42 | 45 | 48 |
43 | 10 44 | 46 | 89 47 |
-------------------------------------------------------------------------------- /yandex_practicum/sprint_7/tasks/D/task.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bufio" 5 | "fmt" 6 | "io" 7 | "log" 8 | "os" 9 | "strconv" 10 | "strings" 11 | ) 12 | 13 | const MOD = 1000000007 14 | 15 | func main() { 16 | s := strings.Builder{} 17 | Solution(os.Stdin, &s) 18 | fmt.Println(s.String()) 19 | } 20 | 21 | func Solution(r io.Reader, s *strings.Builder) { 22 | scanner := bufio.NewScanner(r) 23 | scanner.Scan() 24 | 25 | n, err := strconv.Atoi(scanner.Text()) 26 | if err != nil { 27 | log.Fatal(err) 28 | } 29 | 30 | dp := make([]int, n+1) 31 | dp[0], dp[1] = 1, 1 32 | for i := 2; i < n+1; i++ { 33 | dp[i] = (dp[i-1] + dp[i-2]) % MOD 34 | } 35 | 36 | s.WriteString(fmt.Sprint(dp[n])) 37 | } 38 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_7/tasks/D/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "strings" 7 | "testing" 8 | ) 9 | 10 | type TestItem struct { 11 | input io.Reader 12 | output string 13 | } 14 | 15 | func TestTask(t *testing.T) { 16 | tasks := generateTasks() 17 | 18 | for i, v := range tasks { 19 | t.Run(fmt.Sprintf("Test %d", i+1), func(t *testing.T) { 20 | buf := strings.Builder{} 21 | Solution(v.input, &buf) 22 | if buf.String() != v.output { 23 | t.Errorf("Неверный ответ решения!\nОтвет: \n%v \nВерно: \n%v", buf.String(), v.output) 24 | } 25 | }) 26 | } 27 | } 28 | 29 | func generateTasks() []TestItem { 30 | return []TestItem{ 31 | {strings.NewReader(`5`), "8"}, 32 | {strings.NewReader(`2`), "2"}, 33 | {strings.NewReader(`10`), "89"}, 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_7/tasks/E/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "strings" 7 | "testing" 8 | ) 9 | 10 | type TestItem struct { 11 | input io.Reader 12 | output string 13 | } 14 | 15 | func TestTask(t *testing.T) { 16 | tasks := generateTasks() 17 | 18 | for i, v := range tasks { 19 | t.Run(fmt.Sprintf("Test %d", i+1), func(t *testing.T) { 20 | buf := strings.Builder{} 21 | Solution(v.input, &buf) 22 | if buf.String() != v.output { 23 | t.Errorf("Неверный ответ решения!\nОтвет: \n%v \nВерно: \n%v", buf.String(), v.output) 24 | } 25 | }) 26 | } 27 | } 28 | 29 | func generateTasks() []TestItem { 30 | return []TestItem{ 31 | {strings.NewReader(`130 32 | 4 33 | 10 3 40 1 34 | `), "4"}, 35 | {strings.NewReader(`100 36 | 2 37 | 7 5 38 | `), "16"}, 39 | {strings.NewReader(`1 40 | 1 41 | 1 42 | `), "1"}, 43 | } 44 | } 45 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_7/tasks/F/README.md: -------------------------------------------------------------------------------- 1 | # F. Прыжки по лестнице 2 | 3 | Алла хочет доказать, что она умеет прыгать вверх по лестнице быстрее всех. На этот раз соревнования будут проходить на специальной прыгательной лестнице. С каждой её ступеньки можно прыгнуть вверх на любое расстояние от 1 до k. Число k придумывает Алла. 4 | 5 | Гоша не хочет проиграть, поэтому просит вас посчитать количество способов допрыгать от первой ступеньки до n-й. Изначально все стоят на первой ступеньке. 6 | 7 | ## Формат ввода 8 | 9 | В единственной строке даны два числа — n и k (1 ≤ n ≤ 1000, 1 ≤ k ≤ n). 10 | 11 | ## Формат вывода 12 | 13 | Выведите количество способов по модулю 109 + 7. 14 | 15 | ### Пример 1 16 | 17 | 18 | 21 | 24 |
19 | 6 3 20 | 22 | 13 23 |
25 | 26 | ### Пример 2 27 | 28 | 29 | 32 | 35 |
30 | 7 7 31 | 33 | 32 34 |
36 | 37 | ### Пример 3 38 | 39 | 40 | 43 | 46 |
41 | 2 2 42 | 44 | 1 45 |
47 | 48 | 49 | 50 | 51 | 52 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_7/tasks/F/task.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bufio" 5 | "fmt" 6 | "io" 7 | "log" 8 | "os" 9 | "strconv" 10 | "strings" 11 | ) 12 | 13 | const MOD = 1000000007 14 | 15 | func main() { 16 | s := strings.Builder{} 17 | Solution(os.Stdin, &s) 18 | 19 | fmt.Println(s.String()) 20 | } 21 | 22 | func Solution(r io.Reader, s *strings.Builder) { 23 | scanner := bufio.NewScanner(r) 24 | 25 | var err error 26 | var n, k int 27 | 28 | scanner.Scan() 29 | arrStr := strings.Fields(scanner.Text()) 30 | 31 | n, err = strconv.Atoi(arrStr[0]) 32 | if err != nil { 33 | log.Fatal(err) 34 | } 35 | 36 | k, err = strconv.Atoi(arrStr[1]) 37 | if err != nil { 38 | log.Fatal(err) 39 | } 40 | 41 | ladder := make([]int, n+1) 42 | ladder[0] = 0 43 | ladder[1] = 1 44 | 45 | for i := 2; i < len(ladder); i++ { 46 | if k >= i { 47 | for j := 1; j < i; j++ { 48 | ladder[i] += ladder[j] 49 | } 50 | } else { 51 | for j := i - k; j < i; j++ { 52 | ladder[i] += ladder[j] 53 | } 54 | } 55 | 56 | ladder[i] = ladder[i] % MOD 57 | } 58 | 59 | s.WriteString(fmt.Sprint(ladder[n])) 60 | } 61 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_7/tasks/F/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "strings" 7 | "testing" 8 | ) 9 | 10 | type TestItem struct { 11 | input io.Reader 12 | output string 13 | } 14 | 15 | func TestTask(t *testing.T) { 16 | tasks := generateTasks() 17 | 18 | for i, v := range tasks { 19 | t.Run(fmt.Sprintf("Test %d", i+1), func(t *testing.T) { 20 | buf := strings.Builder{} 21 | Solution(v.input, &buf) 22 | if buf.String() != v.output { 23 | t.Errorf("Неверный ответ решения!\nОтвет: \n%v \nВерно: \n%v", buf.String(), v.output) 24 | } 25 | }) 26 | } 27 | } 28 | 29 | func generateTasks() []TestItem { 30 | return []TestItem{ 31 | {strings.NewReader(`6 3`), "13"}, 32 | {strings.NewReader(`7 7`), "32"}, 33 | {strings.NewReader(`2 2`), "1"}, 34 | {strings.NewReader(`62 44`), "535806680"}, 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_7/tasks/H/README.md: -------------------------------------------------------------------------------- 1 | # H. Поле с цветочками 2 | 3 | Черепаха Кондратина путешествует по клетчатому полю из n строк и m столбцов. В каждой клетке либо растёт цветочек, либо не растёт. Кондратине надо добраться из левого нижнего в правый верхний угол и собрать как можно больше цветочков. 4 | 5 | Помогите ей с этой сложной задачей и определите, какое наибольшее число цветочков она сможет собрать при условии, что Кондратина умеет передвигаться только на одну клетку вверх или на одну клетку вправо за ход. 6 | 7 | ## Формат ввода 8 | 9 | В первой строке даны размеры поля n и m (через пробел). Оба числа лежат в диапазоне от 1 до 1000. В следующих n строках задано поле. Каждая строка состоит из m символов 0 или 1, записанных подряд без пробелов, и завершается переводом строки. Если в клетке записана единица, то в ней растёт цветочек. 10 | 11 | ## Формат вывода 12 | 13 | Выведите единственное число — максимальное количество цветочков, которое сможет собрать Кондратина. 14 | 15 | ### Пример 1 16 | 17 | 18 | 23 | 28 |
19 | 2 3
20 | 101
21 | 110 22 | 		24 | 3
25 |
26 |
27 |
29 | 30 | ### Пример 2 31 | 32 | 33 | 39 | 45 |
34 | 3 3
35 | 100
36 | 110
37 | 001 38 | 		40 | 2
41 |
42 |
43 |
44 |
46 | 47 | 48 | 49 | 50 | 51 | 52 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_7/tasks/H/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "strings" 7 | "testing" 8 | ) 9 | 10 | type TestItem struct { 11 | input io.Reader 12 | output string 13 | } 14 | 15 | func TestTask(t *testing.T) { 16 | tasks := generateTasks() 17 | 18 | for i, v := range tasks { 19 | t.Run(fmt.Sprintf("Test %d", i+1), func(t *testing.T) { 20 | buf := strings.Builder{} 21 | Solution(v.input, &buf) 22 | if buf.String() != v.output { 23 | t.Errorf("Неверный ответ решения!\nОтвет: \n%v \nВерно: \n%v", buf.String(), v.output) 24 | } 25 | }) 26 | } 27 | } 28 | 29 | func generateTasks() []TestItem { 30 | return []TestItem{ 31 | {strings.NewReader(`2 3 32 | 101 33 | 110 34 | `), "3"}, 35 | {strings.NewReader(`3 3 36 | 100 37 | 110 38 | 001 39 | `), "2"}, 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_7/tasks/I/README.md: -------------------------------------------------------------------------------- 1 | # I. Сложное поле с цветочками 2 | 3 | Теперь черепашке Кондратине надо узнать не только, сколько цветочков она может собрать, но и как ей построить свой маршрут для этого. Помогите ей! 4 | 5 | Напомним, что Кондратине надо дойти от левого нижнего до правого верхнего угла, а передвигаться она умеет только вверх и вправо. 6 | 7 | ## Формат ввода 8 | 9 | В первой строке даны размеры поля n и m (через пробел). Оба числа лежат в диапазоне от 1 до 1000. В следующих n строках задано поле. Каждая строка состоит из m символов 0 или 1 и завершается переводом строки. Если в клетке записана единица, то в ней растет цветочек. 10 | 11 | ## Формат вывода 12 | 13 | Выведите в первой строке максимальное количество цветочков, которое сможет собрать Кондратина. Во второй строке выведите маршрут в виде последовательности символов «U» и «R», где «U» означает передвижение вверх, а «R» – передвижение вправо. 14 | 15 | Если возможных оптимальных путей несколько, то выведите любой. 16 | 17 | ### Пример 1 18 | 19 | 20 | 25 | 30 |
21 | 2 3
22 | 101
23 | 110 24 | 		26 | 3
27 | URR
28 |
29 |
31 | 32 | ### Пример 2 33 | 34 | 35 | 41 | 47 |
36 | 3 3
37 | 100
38 | 110
39 | 001 40 | 		42 | 2
43 | URR
44 |
45 |
46 |
48 | 49 | 50 | 51 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_7/tasks/L/README.md: -------------------------------------------------------------------------------- 1 | # L. Золото лепреконов 2 | 3 | Лепреконы в данной задаче появились по соображениям общей морали, так как грабить банки — нехорошо. 4 | 5 | Вам удалось заключить неплохую сделку с лепреконами, поэтому они пустили вас в своё хранилище золотых слитков. Все слитки имеют единую пробу, то есть стоимость 1 грамма золота в двух разных слитках одинакова. В хранилище есть n слитков, вес i-го слитка равен wi кг. У вас есть рюкзак, вместимость которого M килограмм. 6 | 7 | Выясните максимальную суммарную массу золотых слитков, которую вы сможете унести. 8 | 9 | ## Формат ввода 10 | 11 | В первой строке дано число слитков —– натуральное число n (1 ≤ n ≤ 1000) и вместимость рюкзака –— целое число M (0 ≤ M ≤ 104). Во второй строке записано n натуральных чисел wi (1 ≤ wi ≤ 104) -— массы слитков. 12 | 13 | ## Формат вывода 14 | 15 | Выведите единственное число — максимальную массу, которую можно забрать с собой. 16 | 17 | ### Пример 1 18 | 19 | 20 | 24 | 28 |
21 | 5 15
22 | 3 8 1 2 5 23 | 		25 | 15
26 |
27 |
29 | 30 | ### Пример 2 31 | 32 | 33 | 37 | 41 |
34 | 5 19
35 | 10 10 7 7 4 36 | 		38 | 18
39 |
40 |
42 | 43 | 44 | 45 | 46 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_7/tasks/L/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "strings" 7 | "testing" 8 | ) 9 | 10 | type TestItem struct { 11 | input io.Reader 12 | output string 13 | } 14 | 15 | func TestTask(t *testing.T) { 16 | tasks := generateTasks() 17 | 18 | for i, v := range tasks { 19 | t.Run(fmt.Sprintf("Test %d", i+1), func(t *testing.T) { 20 | buf := strings.Builder{} 21 | Solution(v.input, &buf) 22 | if buf.String() != v.output { 23 | t.Errorf("Неверный ответ решения!\nОтвет: \n%v \nВерно: \n%v", buf.String(), v.output) 24 | } 25 | }) 26 | } 27 | } 28 | 29 | func generateTasks() []TestItem { 30 | return []TestItem{ 31 | {strings.NewReader(`5 15 32 | 3 8 1 2 5 33 | `), "15"}, 34 | {strings.NewReader(`5 19 35 | 10 10 7 7 4 36 | `), "18"}, 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_7/tasks/M/README.md: -------------------------------------------------------------------------------- 1 | # M. Рюкзак 2 | 3 | Тимофей решил отправиться в поход. Ему надо собрать рюкзак. Так как поход долгий и трудный, необходимо подбирать вещи вдумчиво. 4 | 5 | Каждому предмету Тимофей присвоил условную значимость: она равна ci для предмета с номером i. Также каждый предмет весит mi килограммов. А грузоподъёмность рюкзака равна M килограмм. 6 | 7 | Найдите максимальную суммарную значимость предметов, которые Тимофей может взять с собой, не порвав рюкзак, и укажите, как набрать эту значимость. 8 | 9 | ## Формат ввода 10 | 11 | В первой строке вводится число предметов n, не превышающее 100 и грузоподъемность M, не превышающая 104. 12 | 13 | Далее следуют описания предметов по одному в строке. Каждый предмет описывается парой mi, ci, оба числа не превосходят 100 по модулю. 14 | 15 | ## Формат вывода 16 | 17 | Выведите в первой строке единственное число — сколько предметов надо взять. Во второй строке перечислите их номера (нумерация с единицы). Если ответов несколько, то выведите любой. 18 | 19 | ### Пример 20 | 21 | 22 | 29 | 36 |
23 | 4 6
24 | 2 7
25 | 4 2
26 | 1 5
27 | 2 1
28 | 		30 | 3
31 | 4 3 1
32 |
33 |
34 |
35 |
37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_7/tasks/M/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "strings" 7 | "testing" 8 | ) 9 | 10 | type TestItem struct { 11 | input io.Reader 12 | output string 13 | } 14 | 15 | func TestTask(t *testing.T) { 16 | tasks := generateTasks() 17 | 18 | for i, v := range tasks { 19 | t.Run(fmt.Sprintf("Test %d", i+1), func(t *testing.T) { 20 | buf := strings.Builder{} 21 | Solution(v.input, &buf) 22 | if buf.String() != v.output { 23 | t.Errorf("Неверный ответ решения!\nОтвет: \n%v \nВерно: \n%v", buf.String(), v.output) 24 | } 25 | }) 26 | } 27 | } 28 | 29 | func generateTasks() []TestItem { 30 | return []TestItem{ 31 | {strings.NewReader(`4 6 32 | 2 7 33 | 4 2 34 | 1 5 35 | 2 1 36 | `), `3 37 | 4 3 1`}, 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_7/tasks/O/README.md: -------------------------------------------------------------------------------- 1 | # O. Количество путей 2 | 3 | Вам дан ациклический ориентированный граф. Найдите в нем количество путей от вершины A до вершины B. Так как потенциально различных путей может быть очень много, то выведите остаток этого числа по модулю 109 + 7. 4 | 5 | ## Формат ввода 6 | 7 | В первой строке дано количество вершин в графе n и ребер m (1 ≤ n ≤ 105, 0 ≤ m ≤ 5 ⋅ 105). В каждой из следующих m строк описаны ребра. Каждое ребро задается своим началом и концом. В последней строке даны вершины A и B (1 ≤ A, B ≤ n). 8 | 9 | ## Формат вывода 10 | 11 | Выведите единственное число – количество путей от A до B по модулю 109 + 7. 12 | 13 | ### Пример 1 14 | 15 | 16 | 23 | 30 |
17 | 3 3
18 | 1 2
19 | 1 2
20 | 2 3
21 | 1 3 22 | 		24 | 2
25 |
26 |
27 |
28 |
29 |
31 | 32 | ### Пример 2 33 | 34 | 35 | 42 | 49 |
36 | 5 3
37 | 1 2
38 | 3 4
39 | 4 5
40 | 1 5 41 | 		43 | 0
44 |
45 |
46 |
47 |
48 |
50 | 51 | ### Пример 3 52 | 53 | 54 | 61 | 68 |
55 | 3 3
56 | 1 2
57 | 2 3
58 | 1 3
59 | 1 1 60 | 		62 | 1
63 |
64 |
65 |
66 |
67 |
69 | 70 | 71 | 72 | 73 | 74 | 75 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_7/tasks/O/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "strings" 7 | "testing" 8 | ) 9 | 10 | type TestItem struct { 11 | input io.Reader 12 | output string 13 | } 14 | 15 | func TestTask(t *testing.T) { 16 | tasks := generateTasks() 17 | 18 | for i, v := range tasks { 19 | t.Run(fmt.Sprintf("Test %d", i+1), func(t *testing.T) { 20 | buf := strings.Builder{} 21 | Solution(v.input, &buf) 22 | if buf.String() != v.output { 23 | t.Errorf("Неверный ответ решения!\nОтвет: \n%v \nВерно: \n%v", buf.String(), v.output) 24 | } 25 | }) 26 | } 27 | } 28 | 29 | func generateTasks() []TestItem { 30 | return []TestItem{ 31 | {strings.NewReader(`3 3 32 | 1 2 33 | 1 2 34 | 2 3 35 | 1 3 36 | `), "2"}, 37 | {strings.NewReader(`5 3 38 | 1 2 39 | 3 4 40 | 4 5 41 | 1 5 42 | `), "0"}, 43 | {strings.NewReader(`3 3 44 | 1 2 45 | 2 3 46 | 1 3 47 | 1 1 48 | `), "1"}, 49 | } 50 | } 51 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_8/final/B/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bufio" 5 | "fmt" 6 | "io" 7 | "strings" 8 | "testing" 9 | ) 10 | 11 | type TestItem struct { 12 | input io.Reader 13 | output string 14 | } 15 | 16 | func TestTask(t *testing.T) { 17 | tasks := generateTasks() 18 | 19 | for i, v := range tasks { 20 | t.Run(fmt.Sprintf("Test %d", i+1), func(t *testing.T) { 21 | buf := strings.Builder{} 22 | s, n := initInput(bufio.NewScanner(v.input)) 23 | Solution(s, n, &buf) 24 | if buf.String() != v.output { 25 | t.Errorf("Неверный ответ решения!\nОтвет: \n%v \nВерно: \n%v", buf.String(), v.output) 26 | } 27 | }) 28 | } 29 | } 30 | 31 | func generateTasks() []TestItem { 32 | return []TestItem{ 33 | {strings.NewReader(`examiwillpasstheexam 34 | 5 35 | will 36 | pass 37 | the 38 | exam 39 | i 40 | `), "YES"}, 41 | {strings.NewReader(`abacaba 42 | 2 43 | abac 44 | caba 45 | `), "NO"}, 46 | {strings.NewReader(`abacaba 47 | 3 48 | abac 49 | caba 50 | aba 51 | `), "YES"}, 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_8/tasks/A/README.md: -------------------------------------------------------------------------------- 1 | # A. Разворот строки 2 | 3 | В некоторых языках предложения пишутся и читаются не слева направо, а справа налево. 4 | 5 | Вам под руку попался странный текст –— в нём обычный (слева направо) порядок букв в словах. А вот сами слова идут в противоположном направлении. Вам надо преобразовать текст так, чтобы слова в нём были написаны слева направо. 6 | 7 | ## Формат ввода 8 | 9 | На ввод подаётся строка, состоящая из слов, разделённых пробелами (один пробел между соседними словами). Всего слов не более 1000, длина каждого из них —– от 1 до 100 символов. Слова состоят из строчных букв английского алфавита. 10 | 11 | ## Формат вывода 12 | 13 | Выведите строку с обратным порядком слов в ней. 14 | 15 | ### Пример 1 16 | 17 | 18 | 21 | 24 |
19 | one two three 20 | 22 | three two one 23 |
25 | 26 | ### Пример 2 27 | 28 | 29 | 32 | 35 |
30 | hello 31 | 33 | hello 34 |
36 | 37 | ### Пример 3 38 | 39 | 40 | 43 | 46 |
41 | may the force be with you 42 | 44 | you with be force the may 45 |
47 | 48 | 49 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_8/tasks/A/task.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bufio" 5 | "fmt" 6 | "io" 7 | "os" 8 | "strings" 9 | ) 10 | 11 | func main() { 12 | s := strings.Builder{} 13 | Solution(os.Stdin, &s) 14 | 15 | fmt.Println(s.String()) 16 | } 17 | 18 | func Solution(r io.Reader, s *strings.Builder) { 19 | scanner := bufio.NewScanner(r) 20 | scanner.Scan() 21 | 22 | fields := strings.Fields(scanner.Text()) 23 | for i, g := 0, len(fields)-1; i < g; i, g = i+1, g-1 { 24 | fields[i], fields[g] = fields[g], fields[i] 25 | } 26 | 27 | s.WriteString(strings.Join(fields, " ")) 28 | } 29 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_8/tasks/A/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "strings" 7 | "testing" 8 | ) 9 | 10 | type TestItem struct { 11 | input io.Reader 12 | output string 13 | } 14 | 15 | func TestTask(t *testing.T) { 16 | tasks := generateTasks() 17 | 18 | for i, v := range tasks { 19 | t.Run(fmt.Sprintf("Test %d", i+1), func(t *testing.T) { 20 | buf := strings.Builder{} 21 | Solution(v.input, &buf) 22 | if buf.String() != v.output { 23 | t.Errorf("Неверный ответ решения!\nОтвет: \n%v \nВерно: \n%v", buf.String(), v.output) 24 | } 25 | }) 26 | } 27 | } 28 | 29 | func generateTasks() []TestItem { 30 | return []TestItem{ 31 | {strings.NewReader(`one two three`), "three two one"}, 32 | {strings.NewReader(`hello`), "hello"}, 33 | {strings.NewReader(`may the force be with you`), "you with be force the may"}, 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_8/tasks/C/README.md: -------------------------------------------------------------------------------- 1 | # C. Самый длинный палиндром 2 2 | 3 | Палиндром —– это строка, которая одинаково читается как слева направо, так и справа налево. 4 | 5 | Из данной строки s путём удаления и перестановки букв надо получить палиндром максимальной длины. Среди всех таких палиндромов надо получить лексикографически минимальный. Количество удалений и перестановок символов может быть любым. 6 | 7 | ## Формат ввода 8 | 9 | В единственной строке дана строка s. Длина строки |s| ≤ 105. Строка состоит из строчных букв английского алфавита. 10 | 11 | ## Формат вывода 12 | 13 | Выведите полученный палиндром. Заметьте, что ответ определяется однозначно. 14 | 15 | ### Пример 1 16 | 17 | 18 | 21 | 24 |
19 | aaaabb 20 | 22 | aabbaa 23 |
25 | 26 | ### Пример 2 27 | 28 | 29 | 32 | 35 |
30 | pabcd 31 | 33 | a 34 |
36 | 37 | ### Пример 3 38 | 39 | 40 | 43 | 46 |
41 | aaabbb 42 | 44 | ababa 45 |
47 | 48 | 49 | 50 | 51 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_8/tasks/D/README.md: -------------------------------------------------------------------------------- 1 | # D. Общий префикс 2 | 3 | Найдите наибольший по длине общий префикс нескольких строк. 4 | 5 | ## Формат ввода 6 | 7 | В первой строке дано число n (1 ≤ n ≤ 105). Затем по одной на строке даны n строк, каждая не превышает 105 в длину. Суммарная длина всех строк не превосходит 107. 8 | 9 | ## Формат вывода 10 | 11 | Выведите единственное число — длину наибольшего префикса всех данных строк. 12 | 13 | ### Пример 1 14 | 15 | 16 | 22 | 28 |
17 | 3
18 | abacaba
19 | abudabi
20 | abcdefg 21 | 		23 | 2
24 |
25 |
26 |
27 |
29 | 30 | ### Пример 2 31 | 32 | 33 | 38 | 43 |
34 | 2
35 | tutu
36 | kukuku 37 | 		39 | 0
40 |
41 |
42 |
44 | 45 | ### Пример 3 46 | 47 | 48 | 54 | 60 |
49 | 3
50 | qwe
51 | qwerty
52 | qwerpy 53 | 		55 | 3
56 |
57 |
58 |
59 |
61 | 62 | 63 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_8/tasks/D/task.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bufio" 5 | "fmt" 6 | "io" 7 | "log" 8 | "os" 9 | "strconv" 10 | "strings" 11 | ) 12 | 13 | func main() { 14 | s := strings.Builder{} 15 | Solution(os.Stdin, &s) 16 | 17 | fmt.Println(s.String()) 18 | } 19 | 20 | func Solution(r io.Reader, s *strings.Builder) { 21 | scanner := bufio.NewScanner(r) 22 | 23 | const bufCapacity = 10000000 // fix long string 24 | buf := make([]byte, bufCapacity) 25 | scanner.Buffer(buf, bufCapacity) 26 | 27 | var err error 28 | var n int 29 | 30 | scanner.Scan() 31 | n, err = strconv.Atoi(scanner.Text()) 32 | if err != nil { 33 | log.Fatal(err) 34 | } 35 | 36 | var last, str string 37 | for i := 0; i < n; i++ { 38 | scanner.Scan() 39 | str = scanner.Text() 40 | 41 | if i == 0 { 42 | last = str 43 | continue 44 | } 45 | 46 | var j, g int 47 | for j < len(last) && g < len(str) && last[j] == str[g] { 48 | j++ 49 | g++ 50 | } 51 | last = str[:g] 52 | } 53 | 54 | s.WriteString(fmt.Sprint(len(last))) 55 | } 56 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_8/tasks/D/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "strings" 7 | "testing" 8 | ) 9 | 10 | type TestItem struct { 11 | input io.Reader 12 | output string 13 | } 14 | 15 | func TestTask(t *testing.T) { 16 | tasks := generateTasks() 17 | 18 | for i, v := range tasks { 19 | t.Run(fmt.Sprintf("Test %d", i+1), func(t *testing.T) { 20 | buf := strings.Builder{} 21 | Solution(v.input, &buf) 22 | if buf.String() != v.output { 23 | t.Errorf("Неверный ответ решения!\nОтвет: \n%v \nВерно: \n%v", buf.String(), v.output) 24 | } 25 | }) 26 | } 27 | } 28 | 29 | func generateTasks() []TestItem { 30 | return []TestItem{ 31 | {strings.NewReader(`3 32 | abacaba 33 | abudabi 34 | abcdefg 35 | `), "2"}, 36 | {strings.NewReader(`2 37 | tutu 38 | kukuku 39 | `), "0"}, 40 | {strings.NewReader(`3 41 | qwe 42 | qwerty 43 | qwerpy 44 | `), "3"}, 45 | } 46 | } 47 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_8/tasks/F/task.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bufio" 5 | "fmt" 6 | "io" 7 | "log" 8 | "os" 9 | "sort" 10 | "strconv" 11 | "strings" 12 | "unicode" 13 | ) 14 | 15 | func main() { 16 | s := strings.Builder{} 17 | Solution(os.Stdin, &s) 18 | 19 | fmt.Println(s.String()) 20 | } 21 | 22 | func Solution(r io.Reader, s *strings.Builder) { 23 | scanner := bufio.NewScanner(r) 24 | 25 | const bufCapacity = 10000000 // fix long string 26 | buf := make([]byte, bufCapacity) 27 | scanner.Buffer(buf, bufCapacity) 28 | 29 | var err error 30 | var n int 31 | 32 | scanner.Scan() 33 | n, err = strconv.Atoi(scanner.Text()) 34 | if err != nil { 35 | log.Fatal(err) 36 | } 37 | 38 | countMap := map[string]int{} 39 | for i := 0; i < n; i++ { 40 | scanner.Scan() 41 | str := scanner.Text() 42 | 43 | if unicode.IsSpace(rune(str[len(str)-1])) { 44 | str = str[:len(str)-1] 45 | } 46 | countMap[str]++ 47 | } 48 | 49 | max := -1 50 | var maxWords []string = nil 51 | for k, v := range countMap { 52 | if max == -1 || v > max { 53 | max = v 54 | maxWords = []string{k} 55 | continue 56 | } else if v == max { 57 | maxWords = append(maxWords, k) 58 | } 59 | } 60 | 61 | sort.Strings(maxWords) 62 | s.WriteString(fmt.Sprint(maxWords[0])) 63 | } 64 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_8/tasks/F/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "strings" 7 | "testing" 8 | ) 9 | 10 | type TestItem struct { 11 | input io.Reader 12 | output string 13 | } 14 | 15 | func TestTask(t *testing.T) { 16 | tasks := generateTasks() 17 | 18 | for i, v := range tasks { 19 | t.Run(fmt.Sprintf("Test %d", i+1), func(t *testing.T) { 20 | buf := strings.Builder{} 21 | Solution(v.input, &buf) 22 | if buf.String() != v.output { 23 | t.Errorf("Неверный ответ решения!\nОтвет: \n%v \nВерно: \n%v", buf.String(), v.output) 24 | } 25 | }) 26 | } 27 | } 28 | 29 | func generateTasks() []TestItem { 30 | return []TestItem{ 31 | {strings.NewReader(`5 32 | caba 33 | aba 34 | caba 35 | abac 36 | aba 37 | `), "aba"}, 38 | {strings.NewReader(`3 39 | b 40 | bc 41 | bcd 42 | `), "b"}, 43 | {strings.NewReader(`10 44 | ciwlaxtnhhrnenw 45 | ciwnvsuni 46 | ciwaxeujmsmvpojqjkxk 47 | ciwnvsuni 48 | ciwnvsuni 49 | ciwuxlkecnofovq 50 | ciwuxlkecnofovq 51 | ciwodramivid 52 | ciwlaxtnhhrnenw 53 | ciwnvsuni 54 | `), "ciwnvsuni"}, 55 | } 56 | } 57 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_8/tasks/G/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "strings" 7 | "testing" 8 | ) 9 | 10 | type TestItem struct { 11 | input io.Reader 12 | output string 13 | } 14 | 15 | func TestTask(t *testing.T) { 16 | tasks := generateTasks() 17 | 18 | for i, v := range tasks { 19 | t.Run(fmt.Sprintf("Test %d", i+1), func(t *testing.T) { 20 | buf := strings.Builder{} 21 | Solution(v.input, &buf) 22 | if strings.TrimSpace(buf.String()) != v.output { 23 | t.Errorf("Неверный ответ решения!\nОтвет: \n%v \nВерно: \n%v", buf.String(), v.output) 24 | } 25 | }) 26 | } 27 | } 28 | 29 | func generateTasks() []TestItem { 30 | return []TestItem{ 31 | {strings.NewReader(`9 32 | 3 9 1 2 5 10 9 1 7 33 | 2 34 | 4 10 35 | `), "1 8"}, 36 | {strings.NewReader(`5 37 | 1 2 3 4 5 38 | 3 39 | 10 11 12 40 | `), "1 2 3"}, 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_8/tasks/H/README.md: -------------------------------------------------------------------------------- 1 | # H. Глобальная замена 2 | 3 | Напишите программу, которая будет заменять в тексте все вхождения строки s на строку t. Гарантируется, что никакие два вхождения шаблона s не пересекаются друг с другом. 4 | 5 | ## Формат ввода 6 | 7 | В первой строке дан текст —– это строка из строчных букв английского алфавита, длина которой не превышает 106. 8 | 9 | Во второй строке записан шаблон s, вхождения которого будут заменены.
10 | В третьей строке дана строка t, которая будет заменять вхождения. 11 | 12 | Обе строки s и t состоят из строчных букв английского алфавита, длина каждой строки не превосходит 105. Размер итоговой строки не превосходит 2⋅ 106. 13 | 14 | ## Формат вывода 15 | 16 | В единственной строке выведите результат всех замен — текст, в котором все вхождения s заменены на t. 17 | 18 | ### Пример 1 19 | 20 | 21 | 26 | 32 |
22 | pingpong
23 | ng
24 | mpi 25 | 		27 | pimpipompi
28 |
29 |
30 |
31 |
33 | 34 | ### Пример 2 35 | 36 | 37 | 42 | 47 |
38 | aaa
39 | a
40 | ab 41 | 		43 | ababab
44 |
45 |
46 |
48 | 49 | 50 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_8/tasks/H/task.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bufio" 5 | "fmt" 6 | "io" 7 | "os" 8 | "strings" 9 | ) 10 | 11 | func main() { 12 | s := strings.Builder{} 13 | Solution(os.Stdin, &s) 14 | 15 | fmt.Println(s.String()) 16 | } 17 | 18 | func Solution(r io.Reader, w *strings.Builder) { 19 | scanner := bufio.NewScanner(r) 20 | 21 | const bufCapacity = 10000000 // fix long string 22 | buf := make([]byte, bufCapacity) 23 | scanner.Buffer(buf, bufCapacity) 24 | 25 | var text, s, t string 26 | 27 | scanner.Scan() 28 | text = scanner.Text() 29 | scanner.Scan() 30 | s = scanner.Text() 31 | scanner.Scan() 32 | t = scanner.Text() 33 | 34 | sentinel := s + "#" + text 35 | patternLen := len(s) 36 | prefixLen := patternLen + 1 37 | 38 | dp := make([]int, len(sentinel)) 39 | result := make([]bool, len(text)) 40 | for i := prefixLen; i < len(sentinel); i++ { 41 | k := dp[i-1] 42 | for sentinel[i] != sentinel[k] && k > 0 { 43 | k = dp[k-1] 44 | } 45 | if sentinel[k] != sentinel[i] { 46 | dp[i] = k 47 | } else { 48 | dp[i] = k + 1 49 | if dp[i] == patternLen { 50 | result[i-patternLen*2] = true 51 | } 52 | } 53 | 54 | } 55 | 56 | for i := 0; i < len(text); i++ { 57 | if result[i] { 58 | w.WriteString(t) 59 | i += patternLen - 1 60 | } else { 61 | w.WriteByte(text[i]) 62 | } 63 | } 64 | } 65 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_8/tasks/H/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "strings" 7 | "testing" 8 | ) 9 | 10 | type TestItem struct { 11 | input io.Reader 12 | output string 13 | } 14 | 15 | func TestTask(t *testing.T) { 16 | tasks := generateTasks() 17 | 18 | for i, v := range tasks { 19 | t.Run(fmt.Sprintf("Test %d", i+1), func(t *testing.T) { 20 | buf := strings.Builder{} 21 | Solution(v.input, &buf) 22 | if buf.String() != v.output { 23 | t.Errorf("Неверный ответ решения!\nОтвет: \n%v \nВерно: \n%v", buf.String(), v.output) 24 | } 25 | }) 26 | } 27 | } 28 | 29 | func generateTasks() []TestItem { 30 | return []TestItem{ 31 | {strings.NewReader(`pingpong 32 | ng 33 | mpi 34 | `), "pimpipompi"}, 35 | {strings.NewReader(`aaa 36 | a 37 | ab 38 | `), "ababab"}, 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_8/tasks/I/task.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bufio" 5 | "fmt" 6 | "io" 7 | "os" 8 | "strings" 9 | ) 10 | 11 | func main() { 12 | s := strings.Builder{} 13 | Solution(os.Stdin, &s) 14 | 15 | fmt.Println(strings.TrimSpace(s.String())) 16 | } 17 | 18 | func Solution(r io.Reader, s *strings.Builder) { 19 | scanner := bufio.NewScanner(r) 20 | 21 | const bufCapacity = 100000000 // fix long string 22 | buf := make([]byte, bufCapacity) 23 | scanner.Buffer(buf, bufCapacity) 24 | 25 | scanner.Scan() 26 | str := scanner.Text() 27 | 28 | prefix := string(str[0]) 29 | prefixLength := len(prefix) 30 | i := 1 31 | 32 | for i+prefixLength <= len(str) { 33 | if prefix == str[i:i+prefixLength] { 34 | i += prefixLength 35 | } else { 36 | i++ 37 | prefix = str[:i] 38 | prefixLength = len(prefix) 39 | } 40 | } 41 | if len(prefix) > len(str)/2 { 42 | prefix = str 43 | prefixLength = len(prefix) 44 | } 45 | 46 | s.WriteString(fmt.Sprint(len(str) / prefixLength)) 47 | } 48 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_8/tasks/I/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "strings" 7 | "testing" 8 | ) 9 | 10 | type TestItem struct { 11 | input io.Reader 12 | output string 13 | } 14 | 15 | func TestTask(t *testing.T) { 16 | tasks := generateTasks() 17 | 18 | for i, v := range tasks { 19 | t.Run(fmt.Sprintf("Test %d", i+1), func(t *testing.T) { 20 | buf := strings.Builder{} 21 | Solution(v.input, &buf) 22 | if strings.TrimSpace(buf.String()) != v.output { 23 | t.Errorf("Неверный ответ решения!\nОтвет: \n%v \nВерно: \n%v", buf.String(), v.output) 24 | } 25 | }) 26 | } 27 | } 28 | 29 | func generateTasks() []TestItem { 30 | return []TestItem{ 31 | {strings.NewReader(`zzzzzz`), "6"}, 32 | {strings.NewReader(`abacaba`), "1"}, 33 | {strings.NewReader(`abababab`), "4"}, 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_8/tasks/K/README.md: -------------------------------------------------------------------------------- 1 | # K. Сравнить две строки 2 | 3 | Алла придумала новый способ сравнивать две строки: чтобы сравнить строки a и b, в них надо оставить только те буквы, которые в английском алфавите стоят на четных позициях. Затем полученные строки сравниваются по обычным правилам. Помогите Алле реализовать новое сравнение строк. 4 | 5 | ## Формат ввода 6 | 7 | На вход подаются строки a и b по одной в строке. Обе строки состоят из маленьких латинских букв, не бывают пустыми и не превосходят 105 символов в длину. 8 | 9 | ## Формат вывода 10 | 11 | Выведите -1, если a < b, 0, если a = b, и 1, если a > b. 12 | 13 | ### Пример 1 14 | 15 | 16 | 20 | 24 |
17 | gggggbbb
18 | bbef 19 | 		21 | -1
22 |
23 |
25 | 26 | ### Пример 2 27 | 28 | 29 | 33 | 37 |
30 | z
31 | aaaaaaa 32 | 		34 | 1
35 |
36 |
38 | 39 | ### Пример 3 40 | 41 | 42 | 46 | 50 |
43 | ccccz
44 | aaaaaz 45 | 		47 | 0
48 |
49 |
51 | 52 | 53 | 54 | 55 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_8/tasks/K/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "strings" 7 | "testing" 8 | ) 9 | 10 | type TestItem struct { 11 | input io.Reader 12 | output string 13 | } 14 | 15 | func TestTask(t *testing.T) { 16 | tasks := generateTasks() 17 | 18 | for i, v := range tasks { 19 | t.Run(fmt.Sprintf("Test %d", i+1), func(t *testing.T) { 20 | buf := strings.Builder{} 21 | Solution(v.input, &buf) 22 | if strings.TrimSpace(buf.String()) != v.output { 23 | t.Errorf("Неверный ответ решения!\nОтвет: \n%v \nВерно: \n%v", buf.String(), v.output) 24 | } 25 | }) 26 | } 27 | } 28 | 29 | func generateTasks() []TestItem { 30 | return []TestItem{ 31 | {strings.NewReader(`gggggbbb 32 | bbef 33 | `), "-1"}, 34 | {strings.NewReader(`z 35 | aaaaaaa 36 | `), "1"}, 37 | {strings.NewReader(`ccccz 38 | aaaaaz 39 | `), "0"}, 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_8/tasks/L/README.md: -------------------------------------------------------------------------------- 1 | # L. Подсчёт префикс-функции 2 | 3 | В этой задаче вам необходимо посчитать префикс-функцию для заданной строки. 4 | 5 | ## Формат ввода 6 | 7 | На вход подаётся строка, состоящая из строчных латинских букв. Длина строки не превосходит 106. 8 | 9 | ## Формат вывода 10 | 11 | Если длина входной строки L, то выведите через пробел L целых неотрицательных чисел —– массив значений префикс-функции исходной строки. 12 | 13 | ### Пример 1 14 | 15 | 16 | 19 | 22 |
17 | abracadabra 18 | 20 | 0 0 0 1 0 1 0 1 2 3 4 21 |
23 | 24 | ### Пример 2 25 | 26 | 27 | 30 | 33 |
28 | xxzzxxz 29 | 31 | 0 1 0 0 1 2 3 32 |
34 | 35 | ### Пример 3 36 | 37 | 38 | 41 | 44 |
39 | aaaaa 40 | 42 | 0 1 2 3 4 43 |
45 | 46 | 47 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_8/tasks/L/task.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bufio" 5 | "fmt" 6 | "io" 7 | "os" 8 | "strconv" 9 | "strings" 10 | ) 11 | 12 | func main() { 13 | s := strings.Builder{} 14 | Solution(os.Stdin, &s) 15 | 16 | fmt.Println(strings.TrimSpace(s.String())) 17 | } 18 | 19 | func Solution(r io.Reader, s *strings.Builder) { 20 | scanner := bufio.NewScanner(r) 21 | 22 | const bufCapacity = 100000000 // fix long string 23 | buf := make([]byte, bufCapacity) 24 | scanner.Buffer(buf, bufCapacity) 25 | 26 | scanner.Scan() 27 | str := scanner.Text() 28 | 29 | dp := make([]int, len(str)) 30 | s.WriteString("0 ") 31 | for i := 1; i < len(str); i++ { 32 | k := dp[i-1] 33 | for k > 0 && str[i] != str[k] { 34 | k = dp[k-1] 35 | } 36 | if str[i] == str[k] { 37 | dp[i] = k + 1 38 | s.WriteString(strconv.Itoa(dp[i]) + " ") 39 | } else { 40 | dp[i] = 0 41 | s.WriteString("0 ") 42 | } 43 | } 44 | } 45 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_8/tasks/L/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "strings" 7 | "testing" 8 | ) 9 | 10 | type TestItem struct { 11 | input io.Reader 12 | output string 13 | } 14 | 15 | func TestTask(t *testing.T) { 16 | tasks := generateTasks() 17 | 18 | for i, v := range tasks { 19 | t.Run(fmt.Sprintf("Test %d", i+1), func(t *testing.T) { 20 | buf := strings.Builder{} 21 | Solution(v.input, &buf) 22 | if strings.TrimSpace(buf.String()) != v.output { 23 | t.Errorf("Неверный ответ решения!\nОтвет: \n%v \nВерно: \n%v", buf.String(), v.output) 24 | } 25 | }) 26 | } 27 | } 28 | 29 | func generateTasks() []TestItem { 30 | return []TestItem{ 31 | {strings.NewReader(`abracadabra`), "0 0 0 1 0 1 0 1 2 3 4"}, 32 | {strings.NewReader(`xxzzxxz`), "0 1 0 0 1 2 3"}, 33 | {strings.NewReader(`aaaaa`), "0 1 2 3 4"}, 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_interview/A/README.md: -------------------------------------------------------------------------------- 1 | # A+B 2 | 3 | Это ваша первая задача. В ней вам придётся прочитать два числа и сложить их. Результат необходимо вывести на стандартный поток вывода или в файл, указанный в условии задачи. 4 | 5 | ## Формат ввода 6 | 7 | В первой строке задано первое число, во второй – второе. Оба числа лежат в диапазоне от − 109 до 109. 8 | 9 | ## Формат вывода 10 | 11 | Выведите единственное число – результат сложения двух чисел. 12 | 13 | ### Пример 1 14 | 15 | 16 | 20 | 21 |
17 | 12
18 | 90 19 | 		102

22 | 23 | ### Пример 2 24 | 25 | 26 | 30 | 31 |
27 | 200
28 | -200 29 | 		0

32 | 33 | ### Пример 3 34 | 35 | 36 | 40 | 41 |
37 | 1000000000
38 | 1000000000 39 | 		2000000000

-------------------------------------------------------------------------------- /yandex_practicum/sprint_interview/A/task.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bufio" 5 | "fmt" 6 | "log" 7 | "os" 8 | "strconv" 9 | ) 10 | 11 | func main() { 12 | a, b := getInputData(bufio.NewScanner(os.Stdin)) 13 | fmt.Println(solution(a, b)) 14 | } 15 | 16 | func solution(a, b int) int { 17 | return a + b 18 | } 19 | 20 | func getInputData(scanner *bufio.Scanner) (a, b int) { 21 | const bufCapacity = 10000000 // fix long 22 | buf := make([]byte, bufCapacity) 23 | scanner.Buffer(buf, bufCapacity) 24 | 25 | var err error 26 | 27 | scanner.Scan() 28 | a, err = strconv.Atoi(scanner.Text()) 29 | if err != nil { 30 | log.Fatal(err) 31 | } 32 | 33 | b, err = strconv.Atoi(scanner.Text()) 34 | if err != nil { 35 | log.Fatal(err) 36 | } 37 | 38 | return 39 | } 40 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_interview/A/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "testing" 6 | ) 7 | 8 | type TestItemInput struct { 9 | a, b int 10 | } 11 | type TestItem struct { 12 | input struct{ a, b int } 13 | output int 14 | } 15 | 16 | func TestTask(t *testing.T) { 17 | tasks := generateTasks() 18 | 19 | for i, v := range tasks { 20 | t.Run(fmt.Sprintf("Test %d", i+1), func(t *testing.T) { 21 | res := solution(v.input.a, v.input.b) 22 | if res != v.output { 23 | t.Errorf("Неверный ответ решения!\nОтвет: \n%v \nВерно: \n%v", res, v.output) 24 | } 25 | }) 26 | } 27 | } 28 | 29 | func generateTasks() []TestItem { 30 | return []TestItem{ 31 | { 32 | input: TestItemInput{a: 12, b: 90}, 33 | output: 102, 34 | }, 35 | { 36 | input: TestItemInput{a: 200, b: -200}, 37 | output: 0, 38 | }, 39 | { 40 | input: TestItemInput{a: 1000000000, b: 1000000000}, 41 | output: 2000000000, 42 | }, 43 | } 44 | } 45 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_interview/B/README.md: -------------------------------------------------------------------------------- 1 | # A. Card Counter 2 | 3 | На стол в ряд выложены карточки, на каждой карточке написано натуральное число. За один ход разрешается взять карточку либо с левого, либо с правого конца ряда. Всего можно сделать 4 | k ходов. Итоговый счет равен сумме чисел на выбранных карточках. Определите, какой максимальный счет можно получить по итогам игры. 5 | 6 | ## Формат ввода 7 | 8 | В первой строке записано число карточек n (1≤n≤105).
9 | Во второй строке записано число ходов k (1≤k≤n).
10 | В третьей строке через пробел даны числа, записанные на карточках. i-е по счету число записано на i-й слева карточке. Все числа натуральные и не превосходят 104. 11 | 12 | ## Формат вывода 13 | 14 | Выведите единственное число —- максимальную сумму очков, которую можно набрать, сделав 15 | k ходов. 16 | 17 | ### Пример 1 18 | 19 | 20 | 25 | 30 |
21 | 7
22 | 3
23 | 5 8 2 1 3 4 11 24 | 		26 | 24
27 |
28 |
29 |
31 | 32 | ### Пример 2 33 | 34 | 35 | 40 | 45 |
36 | 5
37 | 5
38 | 1 2 3 4 5 39 | 		41 | 15
42 |
43 |
44 |
46 | 47 | ### Пример 3 48 | 49 | 50 | 55 | 60 |
51 | 7
52 | 4
53 | 1 1 9 2 2 2 6 54 | 		56 | 17
57 |
58 |
59 |
61 | 62 | 63 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_interview/B/task.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_interview/B/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_interview/C/README.md: -------------------------------------------------------------------------------- 1 | # B. Статус 200 2 | 3 | Вам дан массив натуральных чисел ai. Найдите число таких пар элементов 4 | (ai,aj), где |ai−aj|%200 == 0 и i 9 | Во второй строке через пробел записаны элементы массива ai(1 ≤ ai ≤ 109). 10 | 11 | ## Формат вывода 12 | 13 | Выведите единственное число — количество пар, подходящих под указанное выше условие. 14 | 15 | ### Пример 1 16 | 17 | 18 | 22 | 26 |
19 | 5
20 | 203 404 204 200 403 21 | 		23 | 2
24 |
25 |
27 | 28 | ### Пример 2 29 | 30 | 31 | 35 | 39 |
32 | 1
33 | 1000000 34 | 		36 | 0
37 |
38 |
40 | 41 | ### Пример 3 42 | 43 | 44 | 48 | 52 |
45 | 3
46 | 2022 2020 2021 47 | 		49 | 0
50 |
51 |
53 | 54 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_interview/C/task.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_interview/C/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_interview/D/README.md: -------------------------------------------------------------------------------- 1 | # C. Matrix. Resurrection 2 | 3 | Вам дана матрица из n строк и m столбцов, заполненная натуральными числами. По матрице можно перемещаться, из клетки можно уходить только в соседнюю по стороне клетку, переходы по диагонали, а также выход за границу матрицы запрещены. 4 | 5 | Ваша задача — найти наиболее длинный возрастающий путь в матрице. Путь возрастающий, если значения в посещаемых клетках строго возрастают от начала пути к его концу. 6 | 7 | ## Формат ввода 8 | 9 | В первой строке даны два числа, описывающие размер матрицы — n,m (1 ≤ n,m ≤ 103). 10 | В следующих n строках записана сама матрица. i-я строка матрицы содержит m чисел, записанных через пробел. 11 | Все элементы матрицы — натуральные числа, не превосходящие 109. 12 | 13 | ## Формат вывода 14 | 15 | Выведите единственное число — длину наибольшего возрастающего пути. 16 | 17 | ### Пример 1 18 | 19 | 20 | 25 | 30 |
21 | 2 3
22 | 10 8 5
23 | 10 5 4 24 | 		26 | 4
27 |
28 |
29 |
31 | 32 | ### Пример 2 33 | 34 | 35 | 40 | 45 |
36 | 2 2
37 | 1 1
38 | 1 1 39 | 		41 | 1
42 |
43 |
44 |
46 | 47 | ### Пример 3 48 | 49 | 50 | 55 | 60 |
51 | 2 2
52 | 10 9
53 | 9 11 54 | 		56 | 2
57 |
58 |
59 |
61 | 62 | 63 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_interview/D/task.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_interview/D/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_interview/E/task.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_interview/E/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_interview/F/README.md: -------------------------------------------------------------------------------- 1 | # E. Хорошие строки 2 | 3 | Назовем строку хорошей, если в ней нет двух соседних букв, которые различаются только регистром. Например, строка «abba» хорошая, а строка «aBba» нет. 4 | Со строкой можно делать преобразование: если два соседних символа обозначают одну и ту же букву, но записаны в разных регистрах, то их можно удалить. При этом строка «схлопнется», то есть пробелов при удалении не образуется. 5 | 6 | Цепочкой таких преобразований можно превратить любую строку в хорошую. 7 | 8 | По заданной строке найдите хорошую строку, в которую ее можно превратить. 9 | 10 | ## Формат ввода 11 | 12 | На вход подаётся строка, состоящая из больших и маленьких латинских букв. Длина строки не превосходит 105. 13 | 14 | ## Формат вывода 15 | 16 | Выведите хорошую строку, в которую можно превратить данную. 17 | 18 | ### Пример 1 19 | 20 | 21 | 24 | 27 |
22 | vxOoOoVvx 23 | 25 | vxx 26 |
28 | 29 | ### Пример 2 30 | 31 | 32 | 35 | 38 |
33 | abBa 34 | 36 | aa 37 |
39 | 40 | ### Пример 3 41 | 42 | 43 | 46 | 49 |
44 | AbBa 45 | 47 | 48 |
50 | 51 | 52 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_interview/F/task.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_interview/F/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_interview/G/task.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_interview/G/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_interview/H/README.md: -------------------------------------------------------------------------------- 1 | # G. Сизиф 2 | 3 | В этой задаче вы будете перекладывать камни. Изначально есть n кучек камней. Кучка i весит aiкилограммов. Кучки можно объединять. 4 | При объединении кучек i и j затрачивается ai + aj единиц энергии, при этом две исходные кучки пропадают 5 | и появляется кучка весом ai + aj. 6 | 7 | Определите наименьшее количество энергии, которое надо затратить для объединения всех кучек в одну. 8 | 9 | ## Формат ввода 10 | 11 | В первой строке дано число n (1 ≤ n ≤ 105)
12 | В следующей строке записаны массы кучек через пробел — ai (1 ≤ ai ≤ 106) 13 | 14 | ## Формат вывода 15 | 16 | Выведите единственное число — минимальную энергию, которую надо затратить на объединение всех кучек. 17 | 18 | ### Пример 1 19 | 20 | 21 | 25 | 29 |
22 | 2
23 | 2 6 24 | 		26 | 8
27 |
28 |
30 | 31 | ### Пример 2 32 | 33 | 34 | 38 | 42 |
35 | 3
36 | 6 2 4 37 | 		39 | 18
40 |
41 |
43 | 44 | 45 | 46 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_interview/H/task.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_interview/H/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_interview/I/README.md: -------------------------------------------------------------------------------- 1 | # H. Частичный разворот 2 | 3 | **В этой задаче по умолчанию выбран компилятор Make. Решение отправляется в виде файла с расширением, соответствующим используемому языку.** 4 | 5 | В этой задаче требуется сделать разворот части односвязного списка. Каждая вершина списка описывается структурой Node, каждый экземпляр хранит указатель на следующую вершину или null (nullptr, None, nil), если вершина последняя. По заданным индексам from и to разверните все вершины на отрезке с from до to включительно. 6 | 7 | Заметьте, что нумерация в индексах from и to с единицы. 8 | 9 | Пример для списка из пяти вершин с разворотом от второй до четвертой вершины представлен на рисунке ниже. 10 | 11 | ![IMG](image.png) 12 | 13 | ## Формат ввода 14 | 15 | Реализуйте функцию Reverse, которая принимает голову списка и два целочисленных индекса. 16 | 17 | Используйте шаблон: 18 | 19 | ```go 20 | package main 21 | 22 | // Comment it before submitting 23 | type Node struct { 24 | data string 25 | Next *Node 26 | } 27 | 28 | 29 | func Reverse(head *Node, left int, right int) *Node { 30 | // Your code 31 | // “ヽ(´▽｀)ノ” 32 | } 33 | 34 | ``` 35 | 36 | Гарантируется, что в списке есть хотя бы одна вершина.
37 | Суммарное число вершин не превосходит 105. 38 | 39 | 40 | ## Формат вывода 41 | 42 | Функция Reverse должна возвращать голову изменённого списка. Создавать вершины заново нельзя. -------------------------------------------------------------------------------- /yandex_practicum/sprint_interview/I/image.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dmitryburov/algorithm-practice/1501896081a17ead0f3e5571f9f13cabaf889142/yandex_practicum/sprint_interview/I/image.png -------------------------------------------------------------------------------- /yandex_practicum/sprint_interview/I/task.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_interview/I/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_interview/J/README.md: -------------------------------------------------------------------------------- 1 | # I. Ферзи 2 | 3 | Определите все расстановки из n ферзей на шахматной доске n×n, где ферзи не могут бить друг друга. 4 | 5 | В качестве ответа на задачу выведите в первой строке число расстановок, а далее все расстановки в следующем формате: одна расстановка описывается n числами. i-е число описывает i-ую строку доски, а именно оно равно номеру клетки, в которой стоит ферзь на текущей строке. 6 | Строки нумеруются сверху вниз от 1 до n. Клетки внутри строки нумеруются от 1 до n слева направо. 7 | 8 | ## Формат ввода 9 | 10 | На вход подаётся единственное число n (1 ≤ n ≤ 13). 11 | 12 | ## Формат вывода 13 | 14 | Выведите единственное число — количество возможных расстановок. Далее по одной в строке выведите расстановки в произвольном порядке. 15 | 16 | ### Пример 1 17 | 18 | 19 | 24 | 29 |
20 | 4
21 |
22 |
23 | 		25 | 2
26 | 2 4 1 3
27 | 3 1 4 2 28 |
30 | 31 | ### Пример 2 32 | 33 | 34 | 37 | 40 |
35 | 3 36 | 38 | 0 39 |
41 | 42 | 43 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_interview/J/task.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_interview/J/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_interview/K/README.md: -------------------------------------------------------------------------------- 1 | # J. Разрыв шаблона 2 | 3 | В этой задаче вам надо определить, подходит ли строка под конкретный шаблон. Шаблон задаётся в следующем формате: 4 | 5 | - Символ «?» соответствует одному вхождению любого символа; 6 | - Символ «*» соответствует произвольному числу любых символов, в том числе нулю символов; 7 | - Остальные символы шаблона должны совпадать с символами строки; 8 | 9 | 10 | ## Формат ввода 11 | 12 | В первой строке дан шаблон. 13 | Во второй — проверяемая строка. 14 | 15 | Шаблон и строка не превосходят в длину 2000 символов и не могут быть пустыми. 16 | 17 | Строка состоит только из строчных латинских букв. Шаблон состоит из строчных латинских букв и знаков «?» и «*». 18 | 19 | ## Формат вывода 20 | 21 | Выведите «YES», если строка подходит под шаблон, и «NO», если не подходит. 22 | 23 | ### Пример 1 24 | 25 | 26 | 30 | 34 |
27 | *a*
28 | adce 29 | 		31 | YES
32 |
33 |
35 | 36 | ### Пример 2 37 | 38 | 39 | 43 | 47 |
40 | *
41 | xyz 42 | 		44 | YES
45 |
46 |
48 | 49 | 50 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_interview/K/task.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_interview/K/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_interview/L/task.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_interview/L/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_interview/M/task.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_interview/M/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_interview/N/task.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_interview/N/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_interview/O/task.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_interview/O/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_interview/P/task.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_interview/P/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_interview/Q/README.md: -------------------------------------------------------------------------------- 1 | # P. Прямота 2 | 3 | Вам даны n точек, расположенных на плоскости. Определите, лежат ли все эти точки на одной прямой. 4 | 5 | ## Формат ввода 6 | 7 | В первой строке дано число точек n (2 ≤ n ≤ 105). В следующих n строках по одной в строке заданы сами точки. Каждая точка задаётся двумя координатами — 8 | xiyi, записанными через пробел. Координаты — целые числа, не превосходящие 1012 по модулю. Точки могут совпадать друг с другом. 9 | 10 | ## Формат вывода 11 | 12 | Выведите «YES», если все n точек лежат на одной прямой, и «NO», если нет. 13 | 14 | ### Пример 1 15 | 16 | 17 | 25 | 33 |
18 | 5
19 | 32 6
20 | 29 2
21 | 32 6
22 | 29 2
23 | 35 10 24 | 		26 | YES
27 |
28 |
29 |
30 |
31 |
32 |
34 | 35 | ### Пример 2 36 | 37 | 38 | 43 | 48 |
39 | 2
40 | -22 -75
41 | -30 -70 42 | 		44 | YES
45 |
46 |
47 |
49 | 50 | ### Пример 3 51 | 52 | 53 | 60 | 67 |
54 | 4
55 | 86 -93
56 | 88 -91
57 | 70 -81
58 | 86 -93 59 | 		61 | NO
62 |
63 |
64 |
65 |
66 |
68 | 69 | 70 | 71 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_interview/Q/task.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_interview/Q/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_interview/R/README.md: -------------------------------------------------------------------------------- 1 | # Q. Паша и Марк 2 | 3 | ## Формат ввода 4 | 5 | На вход подаётся единственное число n (1 ≤ n ≤ 10000). 6 | 7 | ## Формат вывода 8 | 9 | Выведите «Pasha», если выиграет Паша, или «Mark», если победа за Марком. 10 | 11 | ### Пример 1 12 | 13 | 14 | 17 | 20 |
15 | 8 16 | 18 | Pasha 19 |
21 | 22 | ### Пример 2 23 | 24 | 25 | 28 | 31 |
26 | 3 27 | 29 | Mark 30 |
32 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_interview/R/task.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_interview/R/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_interview/S/task.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_interview/S/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_interview/T/README.md: -------------------------------------------------------------------------------- 1 | # S. XORошая задача 2 | 3 | В этой задаче требуется по заданному массиву длины n найти два его элемента 4 | xi и xj 5 | (1 ≤ i ≤ j ≤ n), которые давали бы максимальное значение функции 6 | xi ⊕ xj, где под ⊕ подразумевается операция побитового исключающего «или», то есть xor. 7 | 8 | 9 | ## Формат ввода 10 | 11 | В первой строке дан размер массива n (1 ≤ n ≤ 105).
12 | Во второй строке через пробел записаны n целых чисел xi (1 ≤ xi ≤ 231 − 1). 13 | 14 | ## Формат вывода 15 | 16 | Выведите единственное число — максимальное значение xor-а, которое можно получить. 17 | 18 | ### Пример 1 19 | 20 | 21 | 25 | 29 |
22 | 5
23 | 1 8 3 1 4 24 | 		26 | 12
27 |
28 |
30 | 31 | ### Пример 2 32 | 33 | 34 | 38 | 42 |
35 | 3
36 | 4 8 1024 37 | 		39 | 1032
40 |
41 |
43 | 44 | 45 | ### Пример 3 46 | 47 | 48 | 52 | 56 |
49 | 2
50 | 10 10 51 | 		53 | 0
54 |
55 |
57 | 58 | 59 | 60 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_interview/T/task.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_interview/T/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_interview/U/README.md: -------------------------------------------------------------------------------- 1 | # T. Опять скобочные последовательности 2 | 3 | В этой задаче под правильной скобочной последовательностью (ПСП) понимается правильная скобочная последовательность из круглых и квадратных скобок, где ни одна пара квадратных скобок не может содержать пару круглых скобок. 4 | 5 | По данному числу n выведите все ПСП из n скобок в лексикографическом порядке. Упорядоченность символов следующая: ’(’ < ’[’ < ’)’ < ’]’ 6 | 7 | ## Формат ввода 8 | 9 | В единственной строке дано число скобок n, 0 ≤ n ≤16. 10 | 11 | ## Формат вывода 12 | 13 | Выведите правильные скобочные последовательности в лексикографическом порядке по одной в строке. Скобки внутри одной строки идут подряд и не разделяются пробелами 14 | 15 | ### Пример 1 16 | 17 | 18 | 22 | 26 |
19 | 2
20 |
21 | 		23 | ()
24 | [] 25 |
27 | 28 | ### Пример 2 29 | 30 | 31 | 34 | 37 |
32 | 3 33 | 35 | 36 |
38 | 39 | ### Пример 3 40 | 41 | 42 | 51 | 60 |
43 | 4
44 |
45 |
46 |
47 |
48 |
49 |
50 | 		52 | (())
53 | ([])
54 | ()()
55 | ()[]
56 | [[]]
57 | []()
58 | [][] 59 |
-------------------------------------------------------------------------------- /yandex_practicum/sprint_interview/U/task.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /yandex_practicum/sprint_interview/U/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /yandex_training_1/study_1/A/task.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bufio" 5 | "fmt" 6 | "os" 7 | "strconv" 8 | "strings" 9 | ) 10 | 11 | const ( 12 | isAuto = "auto" 13 | isFreeze = "freeze" 14 | isHeat = "heat" 15 | ) 16 | 17 | func main() { 18 | scanner := bufio.NewScanner(os.Stdin) 19 | scanner.Scan() 20 | 21 | temperatures := strings.Fields(scanner.Text()) 22 | t1, _ := strconv.Atoi(temperatures[0]) 23 | t2, _ := strconv.Atoi(temperatures[1]) 24 | 25 | scanner.Scan() 26 | action := scanner.Text() 27 | 28 | fmt.Println(solution(t1, t2, action)) 29 | } 30 | 31 | func solution(t1, t2 int, action string) int { 32 | switch { 33 | case action == isAuto, 34 | action == isFreeze && t1 > t2, 35 | action == isHeat && t1 < t2: 36 | return t2 37 | } 38 | 39 | return t1 40 | } 41 | -------------------------------------------------------------------------------- /yandex_training_1/study_1/A/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "testing" 6 | ) 7 | 8 | type TestItemInput struct { 9 | t1, 10 | t2 int 11 | action string 12 | } 13 | 14 | type TestItemOutput int 15 | 16 | type TestItem struct { 17 | input TestItemInput 18 | output TestItemOutput 19 | } 20 | 21 | func TestTask(t *testing.T) { 22 | for i, v := range generateTasks() { 23 | t.Run(fmt.Sprintf("Test %d", i+1), func(t *testing.T) { 24 | val := solution(v.input.t1, v.input.t2, v.input.action) 25 | if val != int(v.output) { 26 | t.Errorf("Неверный ответ решения!\nОтвет: \n%d \nВерно: \n%d", val, v.output) 27 | } 28 | }) 29 | } 30 | } 31 | 32 | func generateTasks() []TestItem { 33 | return []TestItem{ 34 | {TestItemInput{10, 20, "heat"}, 20}, 35 | {TestItemInput{10, 20, "freeze"}, 10}, 36 | {TestItemInput{10, 20, "auto"}, 20}, 37 | {TestItemInput{-3, -11, "freeze"}, -11}, 38 | {TestItemInput{1, 2, "fan"}, 1}, 39 | {TestItemInput{0, 10, "heat"}, 10}, 40 | {TestItemInput{20, 15, "heat"}, 20}, 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /yandex_training_1/study_1/B/README.md: -------------------------------------------------------------------------------- 1 | # B. Треугольник 2 | 3 | Даны три натуральных числа. Возможно ли построить треугольник с такими сторонами. Если это возможно, выведите строку YES, иначе выведите строку NO. 4 | 5 | Треугольник — это три точки, не лежащие на одной прямой. 6 | 7 | ## Формат ввода 8 | 9 | Вводятся три натуральных числа. 10 | 11 | ## Формат вывода 12 | 13 | Выведите ответ на задачу. YES или NO 14 | 15 | ### Пример 1 16 | 17 | 18 | 23 | 28 |
19 | 3
20 | 4
21 | 5 22 | 		24 | YES
25 |
26 |
27 |
29 | 30 | ### Пример 2 31 | 32 | 33 | 38 | 43 |
34 | 3
35 | 5
36 | 4 37 | 		39 | YES
40 |
41 |
42 |
44 | 45 | ### Пример 3 46 | 47 | 48 | 53 | 58 |
49 | 4
50 | 5
51 | 3 52 | 		54 | YES
55 |
56 |
57 |
59 | -------------------------------------------------------------------------------- /yandex_training_1/study_1/B/task.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bufio" 5 | "fmt" 6 | "os" 7 | "strconv" 8 | ) 9 | 10 | func main() { 11 | scanner := bufio.NewScanner(os.Stdin) 12 | 13 | scanner.Scan() 14 | a, _ := strconv.Atoi(scanner.Text()) 15 | 16 | scanner.Scan() 17 | b, _ := strconv.Atoi(scanner.Text()) 18 | 19 | scanner.Scan() 20 | c, _ := strconv.Atoi(scanner.Text()) 21 | 22 | fmt.Println(solution(a, b, c)) 23 | } 24 | 25 | func solution(a, b, c int) string { 26 | if a+b <= c || b+c <= a || a+c <= b { 27 | return "NO" 28 | } 29 | 30 | return "YES" 31 | } 32 | -------------------------------------------------------------------------------- /yandex_training_1/study_1/B/task_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "testing" 6 | ) 7 | 8 | type TestItemInput struct { 9 | a, 10 | b, 11 | c int 12 | } 13 | 14 | type TestItemOutput string 15 | 16 | type TestItem struct { 17 | input TestItemInput 18 | output TestItemOutput 19 | } 20 | 21 | func TestTask(t *testing.T) { 22 | for i, v := range generateTasks() { 23 | t.Run(fmt.Sprintf("Test %d", i+1), func(t *testing.T) { 24 | val := solution(v.input.a, v.input.b, v.input.c) 25 | if val != string(v.output) { 26 | t.Errorf("Неверный ответ решения!\nОтвет: \n%s \nВерно: \n%s", val, v.output) 27 | } 28 | }) 29 | } 30 | } 31 | 32 | func generateTasks() []TestItem { 33 | return []TestItem{ 34 | {TestItemInput{3, 4, 5}, "YES"}, 35 | {TestItemInput{3, 5, 4}, "YES"}, 36 | {TestItemInput{4, 5, 3}, "YES"}, 37 | {TestItemInput{1, 2, 3}, "NO"}, 38 | } 39 | } 40 | --------------------------------------------------------------------------------