├── .idea
├── .gitignore
├── algos.iml
├── modules.xml
└── vcs.xml
├── sprint1
├── By languages
│ ├── C#
│ │ ├── lesson10code1.cs
│ │ ├── lesson2code1.cs
│ │ ├── lesson4code1.cs
│ │ ├── lesson5code1.cs
│ │ ├── lesson5code2.cs
│ │ ├── lesson6code1.cs
│ │ ├── lesson6code2.cs
│ │ ├── lesson7code1.cs
│ │ ├── lesson7code2.cs
│ │ ├── lesson7code3.cs
│ │ ├── lesson7code4.cs
│ │ ├── lesson7code5.cs
│ │ └── lesson7code6.cs
│ ├── C++
│ │ ├── lesson10code1.cpp
│ │ ├── lesson2code1.cpp
│ │ ├── lesson4code1.cpp
│ │ ├── lesson5code1.cpp
│ │ ├── lesson5code2.cpp
│ │ ├── lesson6code1.cpp
│ │ ├── lesson6code2.cpp
│ │ ├── lesson7code1.cpp
│ │ ├── lesson7code2.cpp
│ │ ├── lesson7code3.cpp
│ │ ├── lesson7code4.cpp
│ │ ├── lesson7code5.cpp
│ │ └── lesson7code6.cpp
│ ├── JS
│ │ ├── lesson10code1.js
│ │ ├── lesson2code1.js
│ │ ├── lesson4code1.js
│ │ ├── lesson5code1.js
│ │ ├── lesson5code2.js
│ │ ├── lesson6code1.js
│ │ ├── lesson6code2.js
│ │ ├── lesson7code1.js
│ │ ├── lesson7code2.js
│ │ ├── lesson7code3.js
│ │ ├── lesson7code4.js
│ │ ├── lesson7code5.js
│ │ └── lesson7code6.js
│ ├── Java
│ │ ├── lesson10code1.java
│ │ ├── lesson2code1.java
│ │ ├── lesson4code1.java
│ │ ├── lesson5code1.java
│ │ ├── lesson5code2.java
│ │ ├── lesson6code1.java
│ │ ├── lesson6code2.java
│ │ ├── lesson7code1.java
│ │ ├── lesson7code2.java
│ │ ├── lesson7code3.java
│ │ ├── lesson7code4.java
│ │ ├── lesson7code5.java
│ │ └── lesson7code6.java
│ ├── go
│ │ ├── lesson10code1.cpp
│ │ ├── lesson10code1.go
│ │ ├── lesson2code1.cpp
│ │ ├── lesson2code1.go
│ │ ├── lesson4code1.cpp
│ │ ├── lesson4code1.go
│ │ ├── lesson5code1.cpp
│ │ ├── lesson5code1.go
│ │ ├── lesson5code2.cpp
│ │ ├── lesson5code2.go
│ │ ├── lesson6code1.cpp
│ │ ├── lesson6code1.go
│ │ ├── lesson6code2.cpp
│ │ ├── lesson6code2.go
│ │ ├── lesson7code1.cpp
│ │ ├── lesson7code1.go
│ │ ├── lesson7code2.cpp
│ │ ├── lesson7code2.go
│ │ ├── lesson7code3.cpp
│ │ ├── lesson7code3.go
│ │ ├── lesson7code4.cpp
│ │ ├── lesson7code4.go
│ │ ├── lesson7code5.cpp
│ │ ├── lesson7code5.go
│ │ ├── lesson7code6.cpp
│ │ └── lesson7code6.go
│ ├── kotlin
│ │ ├── lesson10code1.kt
│ │ ├── lesson2code1.kt
│ │ ├── lesson4code1.kt
│ │ ├── lesson5code1.kt
│ │ ├── lesson5code2.kt
│ │ ├── lesson6code1.kt
│ │ ├── lesson6code2.kt
│ │ ├── lesson7code1.kt
│ │ ├── lesson7code2.kt
│ │ ├── lesson7code3.kt
│ │ ├── lesson7code4.kt
│ │ ├── lesson7code5.kt
│ │ └── lesson7code6.kt
│ ├── python
│ │ ├── lesson10code1.py
│ │ ├── lesson2code1.py
│ │ ├── lesson4code1.py
│ │ ├── lesson5code1.py
│ │ ├── lesson5code2.py
│ │ ├── lesson6code1.py
│ │ ├── lesson6code2.py
│ │ ├── lesson7code1.py
│ │ ├── lesson7code2.py
│ │ ├── lesson7code3.py
│ │ ├── lesson7code4.py
│ │ ├── lesson7code5.py
│ │ └── lesson7code6.py
│ └── swift
│ │ ├── lesson10code1.swift
│ │ ├── lesson2code1.swift
│ │ ├── lesson4code1.swift
│ │ ├── lesson5code1.swift
│ │ ├── lesson5code2.swift
│ │ ├── lesson6code1.swift
│ │ ├── lesson6code2.swift
│ │ ├── lesson7code1.swift
│ │ ├── lesson7code2.swift
│ │ ├── lesson7code3.swift
│ │ ├── lesson7code4.swift
│ │ ├── lesson7code5.swift
│ │ └── lesson7code6.swift
└── By lessons
│ ├── lesson10code1
│ ├── lesson10code1.cpp
│ ├── lesson10code1.cs
│ ├── lesson10code1.go
│ ├── lesson10code1.java
│ ├── lesson10code1.js
│ ├── lesson10code1.kt
│ ├── lesson10code1.py
│ └── lesson10code1.swift
│ ├── lesson2code1
│ ├── lesson2code1.cpp
│ ├── lesson2code1.cs
│ ├── lesson2code1.go
│ ├── lesson2code1.java
│ ├── lesson2code1.js
│ ├── lesson2code1.kt
│ ├── lesson2code1.py
│ └── lesson2code1.swift
│ ├── lesson4code1
│ ├── lesson4code1.cpp
│ ├── lesson4code1.cs
│ ├── lesson4code1.go
│ ├── lesson4code1.java
│ ├── lesson4code1.js
│ ├── lesson4code1.kt
│ ├── lesson4code1.py
│ └── lesson4code1.swift
│ ├── lesson5code1
│ ├── lesson5code1.cpp
│ ├── lesson5code1.cs
│ ├── lesson5code1.go
│ ├── lesson5code1.java
│ ├── lesson5code1.js
│ ├── lesson5code1.kt
│ ├── lesson5code1.py
│ └── lesson5code1.swift
│ ├── lesson5code2
│ ├── lesson5code2.cpp
│ ├── lesson5code2.cs
│ ├── lesson5code2.go
│ ├── lesson5code2.java
│ ├── lesson5code2.js
│ ├── lesson5code2.kt
│ ├── lesson5code2.py
│ └── lesson5code2.swift
│ ├── lesson6code1
│ ├── lesson6code1.cpp
│ ├── lesson6code1.cs
│ ├── lesson6code1.go
│ ├── lesson6code1.java
│ ├── lesson6code1.js
│ ├── lesson6code1.kt
│ ├── lesson6code1.py
│ └── lesson6code1.swift
│ ├── lesson6code2
│ ├── lesson6code2.cpp
│ ├── lesson6code2.cs
│ ├── lesson6code2.go
│ ├── lesson6code2.java
│ ├── lesson6code2.js
│ ├── lesson6code2.kt
│ ├── lesson6code2.py
│ └── lesson6code2.swift
│ ├── lesson7code1
│ ├── lesson7code1.cpp
│ ├── lesson7code1.cs
│ ├── lesson7code1.go
│ ├── lesson7code1.java
│ ├── lesson7code1.js
│ ├── lesson7code1.kt
│ ├── lesson7code1.py
│ └── lesson7code1.swift
│ ├── lesson7code2
│ ├── lesson7code2.cpp
│ ├── lesson7code2.cs
│ ├── lesson7code2.go
│ ├── lesson7code2.java
│ ├── lesson7code2.js
│ ├── lesson7code2.kt
│ ├── lesson7code2.py
│ └── lesson7code2.swift
│ ├── lesson7code3
│ ├── lesson7code3.cpp
│ ├── lesson7code3.cs
│ ├── lesson7code3.go
│ ├── lesson7code3.java
│ ├── lesson7code3.js
│ ├── lesson7code3.kt
│ ├── lesson7code3.py
│ └── lesson7code3.swift
│ ├── lesson7code4
│ ├── lesson7code4.cpp
│ ├── lesson7code4.cs
│ ├── lesson7code4.go
│ ├── lesson7code4.java
│ ├── lesson7code4.js
│ ├── lesson7code4.kt
│ ├── lesson7code4.py
│ └── lesson7code4.swift
│ ├── lesson7code5
│ ├── lesson7code5.cpp
│ ├── lesson7code5.cs
│ ├── lesson7code5.go
│ ├── lesson7code5.java
│ ├── lesson7code5.js
│ ├── lesson7code5.kt
│ ├── lesson7code5.py
│ └── lesson7code5.swift
│ └── lesson7code6
│ ├── lesson7code6.cpp
│ ├── lesson7code6.cs
│ ├── lesson7code6.go
│ ├── lesson7code6.java
│ ├── lesson7code6.js
│ ├── lesson7code6.kt
│ ├── lesson7code6.py
│ └── lesson7code6.swift
├── sprint2
├── By languages
│ ├── C#
│ │ ├── lesson10code1.cs
│ │ ├── lesson11code1.cs
│ │ ├── lesson11code2.cs
│ │ ├── lesson3code1.cs
│ │ ├── lesson5code1.cs
│ │ ├── lesson6code1.cs
│ │ ├── lesson7code1.cs
│ │ └── lesson9code1.cs
│ ├── C++
│ │ ├── lesson10code1.cpp
│ │ ├── lesson11code1.cpp
│ │ ├── lesson11code2.cpp
│ │ ├── lesson3code1.cpp
│ │ ├── lesson5code1.cpp
│ │ ├── lesson6code1.cpp
│ │ ├── lesson7code1.cpp
│ │ └── lesson9code1.cpp
│ ├── JS
│ │ ├── lesson10code1.js
│ │ ├── lesson11code1.js
│ │ ├── lesson11code2.js
│ │ ├── lesson3code1.js
│ │ ├── lesson5code1.js
│ │ ├── lesson6code1.js
│ │ ├── lesson7code1.js
│ │ └── lesson9code1.js
│ ├── Java
│ │ ├── lesson10code1.java
│ │ ├── lesson11code1.java
│ │ ├── lesson11code2.java
│ │ ├── lesson3code1.java
│ │ ├── lesson5code1.java
│ │ ├── lesson6code1.java
│ │ ├── lesson7code1.java
│ │ └── lesson9code1.java
│ ├── go
│ │ ├── lesson10code1.go
│ │ ├── lesson11code1.go
│ │ ├── lesson11code2.go
│ │ ├── lesson3code1.go
│ │ ├── lesson5code1.go
│ │ ├── lesson6code1.go
│ │ ├── lesson7code1.go
│ │ └── lesson9code1.go
│ ├── kotlin
│ │ ├── lesson11code1.kt
│ │ ├── lesson11code2.kt
│ │ ├── lesson3code1.kt
│ │ ├── lesson5code1.kt
│ │ ├── lesson6code1.kt
│ │ ├── lesson7code1.kt
│ │ └── lesson9code1.kt
│ ├── python
│ │ ├── lesson10code1.py
│ │ ├── lesson11code1.py
│ │ ├── lesson11code2.py
│ │ ├── lesson3code1.py
│ │ ├── lesson5code1.py
│ │ ├── lesson6code1.py
│ │ ├── lesson7code1.py
│ │ └── lesson9code1.py
│ └── swift
│ │ ├── lesson10code1.swift
│ │ ├── lesson11code1.swift
│ │ ├── lesson11code2.swift
│ │ ├── lesson3code1.swift
│ │ ├── lesson5code1.swift
│ │ ├── lesson6code1.swift
│ │ ├── lesson7code1.swift
│ │ └── lesson9code1.swift
└── By lessons
│ ├── lesson10code1
│ ├── lesson10code1.cpp
│ ├── lesson10code1.cs
│ ├── lesson10code1.go
│ ├── lesson10code1.java
│ ├── lesson10code1.js
│ ├── lesson10code1.py
│ └── lesson10code1.swift
│ ├── lesson11code1
│ ├── lesson11code1.cpp
│ ├── lesson11code1.cs
│ ├── lesson11code1.go
│ ├── lesson11code1.java
│ ├── lesson11code1.js
│ ├── lesson11code1.kt
│ ├── lesson11code1.py
│ └── lesson11code1.swift
│ ├── lesson11code2
│ ├── lesson11code2.cpp
│ ├── lesson11code2.cs
│ ├── lesson11code2.go
│ ├── lesson11code2.java
│ ├── lesson11code2.js
│ ├── lesson11code2.kt
│ ├── lesson11code2.py
│ └── lesson11code2.swift
│ ├── lesson3code1
│ ├── lesson3code1.cpp
│ ├── lesson3code1.cs
│ ├── lesson3code1.go
│ ├── lesson3code1.java
│ ├── lesson3code1.js
│ ├── lesson3code1.kt
│ ├── lesson3code1.py
│ └── lesson3code1.swift
│ ├── lesson5code1
│ ├── lesson5code1.cpp
│ ├── lesson5code1.cs
│ ├── lesson5code1.go
│ ├── lesson5code1.java
│ ├── lesson5code1.js
│ ├── lesson5code1.kt
│ ├── lesson5code1.py
│ └── lesson5code1.swift
│ ├── lesson6code1
│ ├── lesson6code1.cpp
│ ├── lesson6code1.cs
│ ├── lesson6code1.go
│ ├── lesson6code1.java
│ ├── lesson6code1.js
│ ├── lesson6code1.kt
│ ├── lesson6code1.py
│ └── lesson6code1.swift
│ ├── lesson7code1
│ ├── lesson7code1.cpp
│ ├── lesson7code1.cs
│ ├── lesson7code1.go
│ ├── lesson7code1.java
│ ├── lesson7code1.js
│ ├── lesson7code1.kt
│ ├── lesson7code1.py
│ └── lesson7code1.swift
│ └── lesson9code1
│ ├── lesson9code1.cpp
│ ├── lesson9code1.cs
│ ├── lesson9code1.go
│ ├── lesson9code1.java
│ ├── lesson9code1.js
│ ├── lesson9code1.kt
│ ├── lesson9code1.py
│ └── lesson9code1.swift
├── sprint3
├── By languages
│ ├── C#
│ │ ├── lesson11code1.cs
│ │ ├── lesson12code1.cs
│ │ ├── lesson14code1.cs
│ │ ├── lesson1code1.cs
│ │ ├── lesson1code2.cs
│ │ ├── lesson1code3.cs
│ │ ├── lesson2code1.cs
│ │ ├── lesson2code2.cs
│ │ ├── lesson2code3.cs
│ │ ├── lesson2code4.cs
│ │ ├── lesson3code1.cs
│ │ ├── lesson3code2.cs
│ │ ├── lesson4code1.cs
│ │ ├── lesson7code1.cs
│ │ ├── lesson8code1.cs
│ │ ├── lesson8code2.cs
│ │ └── lesson9code1.cs
│ ├── C++
│ │ ├── lesson11code1.cpp
│ │ ├── lesson12code1.cpp
│ │ ├── lesson14code1.cpp
│ │ ├── lesson1code1.cpp
│ │ ├── lesson1code2.cpp
│ │ ├── lesson1code3.cpp
│ │ ├── lesson2code1.cpp
│ │ ├── lesson2code2.cpp
│ │ ├── lesson2code3.cpp
│ │ ├── lesson2code4.cpp
│ │ ├── lesson3code1.cpp
│ │ ├── lesson3code2.cpp
│ │ ├── lesson4code1.cpp
│ │ ├── lesson7code1.cpp
│ │ ├── lesson8code1.cpp
│ │ ├── lesson8code2.cpp
│ │ └── lesson9code1.cpp
│ ├── JS
│ │ ├── lesson11code1.js
│ │ ├── lesson12code1.js
│ │ ├── lesson14code1.js
│ │ ├── lesson1code1.js
│ │ ├── lesson1code2.js
│ │ ├── lesson1code3.js
│ │ ├── lesson2code1.js
│ │ ├── lesson2code2.js
│ │ ├── lesson2code3.js
│ │ ├── lesson2code4.js
│ │ ├── lesson3code1.js
│ │ ├── lesson3code2.js
│ │ ├── lesson4code1.js
│ │ ├── lesson7code1.js
│ │ ├── lesson8code1.js
│ │ ├── lesson8code2.js
│ │ └── lesson9code1.js
│ ├── Java
│ │ ├── lesson11code1.java
│ │ ├── lesson12code1.java
│ │ ├── lesson14code1.java
│ │ ├── lesson1code1.java
│ │ ├── lesson1code2.java
│ │ ├── lesson1code3.java
│ │ ├── lesson2code1.java
│ │ ├── lesson2code2.java
│ │ ├── lesson2code3.java
│ │ ├── lesson2code4.java
│ │ ├── lesson3code1.java
│ │ ├── lesson3code2.java
│ │ ├── lesson4code1.java
│ │ ├── lesson7code1.java
│ │ ├── lesson8code1.java
│ │ ├── lesson8code2.java
│ │ └── lesson9code1.java
│ ├── go
│ │ ├── lesson11code1.go
│ │ ├── lesson12code1.go
│ │ ├── lesson14code1.go
│ │ ├── lesson1code1.go
│ │ ├── lesson1code2.go
│ │ ├── lesson1code3.go
│ │ ├── lesson2code1.go
│ │ ├── lesson2code2.go
│ │ ├── lesson2code3.go
│ │ ├── lesson2code4.go
│ │ ├── lesson3code1.go
│ │ ├── lesson3code2.go
│ │ ├── lesson4code1.go
│ │ ├── lesson7code1.go
│ │ ├── lesson8code1.go
│ │ ├── lesson8code2.go
│ │ └── lesson9code1.go
│ ├── kotlin
│ │ ├── lesson11code1.kt
│ │ ├── lesson12code1.kt
│ │ ├── lesson14code1.kt
│ │ ├── lesson1code1.kt
│ │ ├── lesson1code2.kt
│ │ ├── lesson1code3.kt
│ │ ├── lesson2code1.kt
│ │ ├── lesson2code2.kt
│ │ ├── lesson2code3.kt
│ │ ├── lesson2code4.kt
│ │ ├── lesson3code1.kt
│ │ ├── lesson3code2.kt
│ │ ├── lesson4code1.kt
│ │ ├── lesson7code1.kt
│ │ ├── lesson8code1.kt
│ │ ├── lesson8code2.kt
│ │ └── lesson9code1.kt
│ ├── python
│ │ ├── lesson11code1.py
│ │ ├── lesson12code1.py
│ │ ├── lesson14code1.py
│ │ ├── lesson1code1.py
│ │ ├── lesson1code2.py
│ │ ├── lesson1code3.py
│ │ ├── lesson2code1.py
│ │ ├── lesson2code2.py
│ │ ├── lesson2code3.py
│ │ ├── lesson2code4.py
│ │ ├── lesson3code1.py
│ │ ├── lesson3code2.py
│ │ ├── lesson4code1.py
│ │ ├── lesson7code1.py
│ │ ├── lesson8code1.py
│ │ ├── lesson8code2.py
│ │ └── lesson9code1.py
│ └── swift
│ │ ├── lesson11code1.swift
│ │ ├── lesson12code1.swift
│ │ ├── lesson14code1.swift
│ │ ├── lesson1code1.swift
│ │ ├── lesson1code2.swift
│ │ ├── lesson1code3.swift
│ │ ├── lesson2code1.swift
│ │ ├── lesson2code2.swift
│ │ ├── lesson2code3.swift
│ │ ├── lesson2code4.swift
│ │ ├── lesson3code1.swift
│ │ ├── lesson3code2.swift
│ │ ├── lesson4code1.swift
│ │ ├── lesson7code1.swift
│ │ ├── lesson8code1.swift
│ │ ├── lesson8code2.swift
│ │ └── lesson9code1.swift
└── By lessons
│ ├── lesson11code1
│ ├── lesson11code1.cpp
│ ├── lesson11code1.cs
│ ├── lesson11code1.go
│ ├── lesson11code1.java
│ ├── lesson11code1.js
│ ├── lesson11code1.kt
│ ├── lesson11code1.py
│ └── lesson11code1.swift
│ ├── lesson12code1
│ ├── lesson12code1.cpp
│ ├── lesson12code1.cs
│ ├── lesson12code1.go
│ ├── lesson12code1.java
│ ├── lesson12code1.js
│ ├── lesson12code1.kt
│ ├── lesson12code1.py
│ └── lesson12code1.swift
│ ├── lesson14code1
│ ├── lesson14code1.cpp
│ ├── lesson14code1.cs
│ ├── lesson14code1.go
│ ├── lesson14code1.java
│ ├── lesson14code1.js
│ ├── lesson14code1.kt
│ ├── lesson14code1.py
│ └── lesson14code1.swift
│ ├── lesson1code1
│ ├── lesson1code1.cpp
│ ├── lesson1code1.cs
│ ├── lesson1code1.go
│ ├── lesson1code1.java
│ ├── lesson1code1.js
│ ├── lesson1code1.kt
│ ├── lesson1code1.py
│ └── lesson1code1.swift
│ ├── lesson1code2
│ ├── lesson1code2.cpp
│ ├── lesson1code2.cs
│ ├── lesson1code2.go
│ ├── lesson1code2.java
│ ├── lesson1code2.js
│ ├── lesson1code2.kt
│ ├── lesson1code2.py
│ └── lesson1code2.swift
│ ├── lesson1code3
│ ├── lesson1code3.cpp
│ ├── lesson1code3.cs
│ ├── lesson1code3.go
│ ├── lesson1code3.java
│ ├── lesson1code3.js
│ ├── lesson1code3.kt
│ ├── lesson1code3.py
│ └── lesson1code3.swift
│ ├── lesson2code1
│ ├── lesson2code1.cpp
│ ├── lesson2code1.cs
│ ├── lesson2code1.go
│ ├── lesson2code1.java
│ ├── lesson2code1.js
│ ├── lesson2code1.kt
│ ├── lesson2code1.py
│ └── lesson2code1.swift
│ ├── lesson2code2
│ ├── lesson2code2.cpp
│ ├── lesson2code2.cs
│ ├── lesson2code2.go
│ ├── lesson2code2.java
│ ├── lesson2code2.js
│ ├── lesson2code2.kt
│ ├── lesson2code2.py
│ └── lesson2code2.swift
│ ├── lesson2code3
│ ├── lesson2code3.cpp
│ ├── lesson2code3.cs
│ ├── lesson2code3.go
│ ├── lesson2code3.java
│ ├── lesson2code3.js
│ ├── lesson2code3.kt
│ ├── lesson2code3.py
│ └── lesson2code3.swift
│ ├── lesson2code4
│ ├── lesson2code4.cpp
│ ├── lesson2code4.cs
│ ├── lesson2code4.go
│ ├── lesson2code4.java
│ ├── lesson2code4.js
│ ├── lesson2code4.kt
│ ├── lesson2code4.py
│ └── lesson2code4.swift
│ ├── lesson3code1
│ ├── lesson3code1.cpp
│ ├── lesson3code1.cs
│ ├── lesson3code1.go
│ ├── lesson3code1.java
│ ├── lesson3code1.js
│ ├── lesson3code1.kt
│ ├── lesson3code1.py
│ └── lesson3code1.swift
│ ├── lesson3code2
│ ├── lesson3code2.cpp
│ ├── lesson3code2.cs
│ ├── lesson3code2.go
│ ├── lesson3code2.java
│ ├── lesson3code2.js
│ ├── lesson3code2.kt
│ ├── lesson3code2.py
│ └── lesson3code2.swift
│ ├── lesson4code1
│ ├── lesson4code1.cpp
│ ├── lesson4code1.cs
│ ├── lesson4code1.go
│ ├── lesson4code1.java
│ ├── lesson4code1.js
│ ├── lesson4code1.kt
│ ├── lesson4code1.py
│ └── lesson4code1.swift
│ ├── lesson7code1
│ ├── lesson7code1.cpp
│ ├── lesson7code1.cs
│ ├── lesson7code1.go
│ ├── lesson7code1.java
│ ├── lesson7code1.js
│ ├── lesson7code1.kt
│ ├── lesson7code1.py
│ └── lesson7code1.swift
│ ├── lesson8code1
│ ├── lesson8code1.cpp
│ ├── lesson8code1.cs
│ ├── lesson8code1.go
│ ├── lesson8code1.java
│ ├── lesson8code1.js
│ ├── lesson8code1.kt
│ ├── lesson8code1.py
│ └── lesson8code1.swift
│ ├── lesson8code2
│ ├── lesson8code2.cpp
│ ├── lesson8code2.cs
│ ├── lesson8code2.go
│ ├── lesson8code2.java
│ ├── lesson8code2.js
│ ├── lesson8code2.kt
│ ├── lesson8code2.py
│ └── lesson8code2.swift
│ └── lesson9code1
│ ├── lesson9code1.cpp
│ ├── lesson9code1.cs
│ ├── lesson9code1.go
│ ├── lesson9code1.java
│ ├── lesson9code1.js
│ ├── lesson9code1.kt
│ ├── lesson9code1.py
│ └── lesson9code1.swift
├── sprint4
├── By languages
│ ├── C#
│ │ ├── lesson10code1.cs
│ │ ├── lesson10code2.cs
│ │ ├── lesson1code1.cs
│ │ ├── lesson1code2.cs
│ │ ├── lesson1code3.cs
│ │ └── lesson1code4.cs
│ ├── C++
│ │ ├── lesson10code1.cpp
│ │ ├── lesson10code2.cpp
│ │ ├── lesson1code1.cpp
│ │ ├── lesson1code2.cpp
│ │ ├── lesson1code3.cpp
│ │ └── lesson1code4.cpp
│ ├── JS
│ │ ├── lesson10code1.js
│ │ ├── lesson10code2.js
│ │ ├── lesson1code1.js
│ │ ├── lesson1code2.js
│ │ ├── lesson1code3.js
│ │ └── lesson1code4.js
│ ├── Java
│ │ ├── lesson10code1.java
│ │ ├── lesson10code2.java
│ │ ├── lesson1code1.java
│ │ ├── lesson1code2.java
│ │ ├── lesson1code3.java
│ │ └── lesson1code4.java
│ ├── go
│ │ ├── lesson10code1.go
│ │ ├── lesson10code2.go
│ │ ├── lesson1code1.go
│ │ ├── lesson1code2.go
│ │ ├── lesson1code3.go
│ │ └── lesson1code4.go
│ ├── kotlin
│ │ ├── lesson10code1.kt
│ │ ├── lesson10code2.kt
│ │ ├── lesson1code1.kt
│ │ ├── lesson1code2.kt
│ │ ├── lesson1code3.kt
│ │ ├── lesson1code4.kt
│ │ └── lesson2code1.kt
│ ├── python
│ │ ├── lesson10code1.py
│ │ ├── lesson10code2.py
│ │ ├── lesson1code1.py
│ │ ├── lesson1code2.py
│ │ ├── lesson1code3.py
│ │ └── lesson1code4.py
│ └── swift
│ │ ├── lesson10code1.swift
│ │ ├── lesson10code2.swift
│ │ ├── lesson1code1.swift
│ │ ├── lesson1code2.swift
│ │ ├── lesson1code3.swift
│ │ └── lesson1code4.swift
└── By lessons
│ ├── lesson10code1
│ ├── lesson10code1.cpp
│ ├── lesson10code1.cs
│ ├── lesson10code1.go
│ ├── lesson10code1.java
│ ├── lesson10code1.js
│ ├── lesson10code1.kt
│ ├── lesson10code1.py
│ └── lesson10code1.swift
│ ├── lesson10code2
│ ├── lesson10code2.cpp
│ ├── lesson10code2.cs
│ ├── lesson10code2.go
│ ├── lesson10code2.java
│ ├── lesson10code2.js
│ ├── lesson10code2.kt
│ ├── lesson10code2.py
│ └── lesson10code2.swift
│ ├── lesson1code1
│ ├── lesson1code1.cpp
│ ├── lesson1code1.cs
│ ├── lesson1code1.go
│ ├── lesson1code1.java
│ ├── lesson1code1.js
│ ├── lesson1code1.kt
│ ├── lesson1code1.py
│ └── lesson1code1.swift
│ ├── lesson1code2
│ ├── lesson1code2.cpp
│ ├── lesson1code2.cs
│ ├── lesson1code2.go
│ ├── lesson1code2.java
│ ├── lesson1code2.js
│ ├── lesson1code2.kt
│ ├── lesson1code2.py
│ └── lesson1code2.swift
│ ├── lesson1code3
│ ├── lesson1code3.cpp
│ ├── lesson1code3.cs
│ ├── lesson1code3.go
│ ├── lesson1code3.java
│ ├── lesson1code3.js
│ ├── lesson1code3.kt
│ ├── lesson1code3.py
│ └── lesson1code3.swift
│ ├── lesson1code4
│ ├── lesson1code4.cpp
│ ├── lesson1code4.cs
│ ├── lesson1code4.go
│ ├── lesson1code4.java
│ ├── lesson1code4.js
│ ├── lesson1code4.kt
│ ├── lesson1code4.py
│ └── lesson1code4.swift
│ └── lesson2code1
│ ├── lesson2code1.cpp
│ ├── lesson2code1.cs
│ ├── lesson2code1.go
│ ├── lesson2code1.java
│ ├── lesson2code1.js
│ ├── lesson2code1.kt
│ ├── lesson2code1.py
│ └── lesson2code1.swift
├── sprint5
├── .DS_Store
├── By languages
│ ├── C#
│ │ ├── lesson2code1.cs
│ │ ├── lesson2code2.cs
│ │ ├── lesson3code1.cs
│ │ ├── lesson4code1.cs
│ │ ├── lesson4code2.cs
│ │ ├── lesson4code3.cs
│ │ ├── lesson5code1.cs
│ │ ├── lesson8code1.cs
│ │ ├── lesson8code2.cs
│ │ ├── lesson8code3.cs
│ │ ├── lesson8code4.cs
│ │ └── lesson8code5.cs
│ ├── C++
│ │ ├── lesson2code1.cpp
│ │ ├── lesson2code2.cpp
│ │ ├── lesson3code1.cpp
│ │ ├── lesson4code1.cpp
│ │ ├── lesson4code2.cpp
│ │ ├── lesson4code3.cpp
│ │ ├── lesson5code1.cpp
│ │ ├── lesson8code1.cpp
│ │ ├── lesson8code2.cpp
│ │ ├── lesson8code3.cpp
│ │ ├── lesson8code4.cpp
│ │ └── lesson8code5.cpp
│ ├── JS
│ │ ├── lesson2code1.js
│ │ ├── lesson2code2.js
│ │ ├── lesson3code1.js
│ │ ├── lesson4code1.js
│ │ ├── lesson4code2.js
│ │ ├── lesson4code3.js
│ │ ├── lesson5code1.js
│ │ ├── lesson8code1.js
│ │ ├── lesson8code2.js
│ │ ├── lesson8code3.js
│ │ ├── lesson8code4.js
│ │ └── lesson8code5.js
│ ├── Java
│ │ ├── lesson2code1.java
│ │ ├── lesson2code2.java
│ │ ├── lesson3code1.java
│ │ ├── lesson4code1.java
│ │ ├── lesson4code2.java
│ │ ├── lesson4code3.java
│ │ ├── lesson5code1.java
│ │ ├── lesson8code1.java
│ │ ├── lesson8code2.java
│ │ ├── lesson8code3.java
│ │ ├── lesson8code4.java
│ │ └── lesson8code5.java
│ ├── go
│ │ ├── lesson2code1.go
│ │ ├── lesson2code2.go
│ │ ├── lesson3code1.go
│ │ ├── lesson4code1.go
│ │ ├── lesson4code2.go
│ │ ├── lesson4code3.go
│ │ ├── lesson5code1.go
│ │ ├── lesson8code1.go
│ │ ├── lesson8code2.go
│ │ ├── lesson8code3.go
│ │ ├── lesson8code4.go
│ │ └── lesson8code5.go
│ ├── kotlin
│ │ ├── lesson10code1.kt
│ │ ├── lesson10code2.kt
│ │ ├── lesson11code1.kt
│ │ ├── lesson12code1.kt
│ │ ├── lesson12code2.kt
│ │ ├── lesson12code3.kt
│ │ ├── lesson2code1.kt
│ │ ├── lesson2code2.kt
│ │ ├── lesson3code1.kt
│ │ ├── lesson4code1.kt
│ │ ├── lesson4code2.kt
│ │ ├── lesson4code3.kt
│ │ ├── lesson5code1.kt
│ │ ├── lesson8code1.kt
│ │ ├── lesson8code2.kt
│ │ ├── lesson8code3.kt
│ │ ├── lesson8code4.kt
│ │ └── lesson8code5.kt
│ ├── python
│ │ ├── lesson2code1.py
│ │ ├── lesson2code2.py
│ │ ├── lesson3code1.py
│ │ ├── lesson4code1.py
│ │ ├── lesson4code2.py
│ │ ├── lesson4code3.py
│ │ ├── lesson5code1.py
│ │ ├── lesson8code1.py
│ │ ├── lesson8code2.py
│ │ ├── lesson8code3.py
│ │ ├── lesson8code4.py
│ │ └── lesson8code5.py
│ └── swift
│ │ ├── lesson2code1.swift
│ │ ├── lesson2code2.swift
│ │ ├── lesson3code1.swift
│ │ ├── lesson4code1.swift
│ │ ├── lesson4code2.swift
│ │ ├── lesson4code3.swift
│ │ ├── lesson5code1.swift
│ │ ├── lesson8code1.swift
│ │ ├── lesson8code2.swift
│ │ ├── lesson8code3.swift
│ │ ├── lesson8code4.swift
│ │ └── lesson8code5.swift
└── By lessons
│ ├── lesson10code1
│ ├── lesson10code1.cpp
│ ├── lesson10code1.cs
│ ├── lesson10code1.go
│ ├── lesson10code1.java
│ ├── lesson10code1.js
│ ├── lesson10code1.kt
│ ├── lesson10code1.py
│ └── lesson10code1.swift
│ ├── lesson10code2
│ ├── lesson10code2.cpp
│ ├── lesson10code2.cs
│ ├── lesson10code2.go
│ ├── lesson10code2.java
│ ├── lesson10code2.js
│ ├── lesson10code2.kt
│ ├── lesson10code2.py
│ └── lesson10code2.swift
│ ├── lesson11code1
│ ├── lesson11code1.cpp
│ ├── lesson11code1.cs
│ ├── lesson11code1.go
│ ├── lesson11code1.java
│ ├── lesson11code1.js
│ ├── lesson11code1.kt
│ ├── lesson11code1.py
│ └── lesson11code1.swift
│ ├── lesson12code1
│ ├── lesson12code1.cpp
│ ├── lesson12code1.cs
│ ├── lesson12code1.go
│ ├── lesson12code1.java
│ ├── lesson12code1.js
│ ├── lesson12code1.kt
│ ├── lesson12code1.py
│ └── lesson12code1.swift
│ ├── lesson12code2
│ ├── lesson12code2.cpp
│ ├── lesson12code2.cs
│ ├── lesson12code2.go
│ ├── lesson12code2.java
│ ├── lesson12code2.js
│ ├── lesson12code2.kt
│ ├── lesson12code2.py
│ └── lesson12code2.swift
│ ├── lesson12code3
│ ├── lesson12code3.cpp
│ ├── lesson12code3.cs
│ ├── lesson12code3.go
│ ├── lesson12code3.java
│ ├── lesson12code3.js
│ ├── lesson12code3.kt
│ ├── lesson12code3.py
│ └── lesson12code3.swift
│ ├── lesson2code1
│ ├── lesson2code1.cpp
│ ├── lesson2code1.cs
│ ├── lesson2code1.go
│ ├── lesson2code1.java
│ ├── lesson2code1.js
│ ├── lesson2code1.kt
│ ├── lesson2code1.py
│ └── lesson2code1.swift
│ ├── lesson2code2
│ ├── lesson2code2.cpp
│ ├── lesson2code2.cs
│ ├── lesson2code2.go
│ ├── lesson2code2.java
│ ├── lesson2code2.js
│ ├── lesson2code2.kt
│ ├── lesson2code2.py
│ └── lesson2code2.swift
│ ├── lesson3code1
│ ├── lesson3code1.cpp
│ ├── lesson3code1.cs
│ ├── lesson3code1.go
│ ├── lesson3code1.java
│ ├── lesson3code1.js
│ ├── lesson3code1.kt
│ ├── lesson3code1.py
│ └── lesson3code1.swift
│ ├── lesson4code1
│ ├── lesson4code1.cpp
│ ├── lesson4code1.cs
│ ├── lesson4code1.go
│ ├── lesson4code1.java
│ ├── lesson4code1.js
│ ├── lesson4code1.kt
│ ├── lesson4code1.py
│ └── lesson4code1.swift
│ ├── lesson4code2
│ ├── lesson4code2.cpp
│ ├── lesson4code2.cs
│ ├── lesson4code2.go
│ ├── lesson4code2.java
│ ├── lesson4code2.js
│ ├── lesson4code2.kt
│ ├── lesson4code2.py
│ └── lesson4code2.swift
│ ├── lesson4code3
│ ├── lesson4code3.cpp
│ ├── lesson4code3.cs
│ ├── lesson4code3.go
│ ├── lesson4code3.java
│ ├── lesson4code3.js
│ ├── lesson4code3.kt
│ ├── lesson4code3.py
│ └── lesson4code3.swift
│ ├── lesson5code1
│ ├── lesson5code1.cpp
│ ├── lesson5code1.cs
│ ├── lesson5code1.go
│ ├── lesson5code1.java
│ ├── lesson5code1.js
│ ├── lesson5code1.kt
│ ├── lesson5code1.py
│ └── lesson5code1.swift
│ ├── lesson8code1
│ ├── lesson8code1.cpp
│ ├── lesson8code1.cs
│ ├── lesson8code1.go
│ ├── lesson8code1.java
│ ├── lesson8code1.js
│ ├── lesson8code1.kt
│ ├── lesson8code1.py
│ └── lesson8code1.swift
│ ├── lesson8code2
│ ├── lesson8code2.cpp
│ ├── lesson8code2.cs
│ ├── lesson8code2.go
│ ├── lesson8code2.java
│ ├── lesson8code2.js
│ ├── lesson8code2.kt
│ ├── lesson8code2.py
│ └── lesson8code2.swift
│ ├── lesson8code3
│ ├── lesson8code3.cpp
│ ├── lesson8code3.cs
│ ├── lesson8code3.go
│ ├── lesson8code3.java
│ ├── lesson8code3.js
│ ├── lesson8code3.kt
│ ├── lesson8code3.py
│ └── lesson8code3.swift
│ ├── lesson8code4
│ ├── lesson8code4.cpp
│ ├── lesson8code4.cs
│ ├── lesson8code4.go
│ ├── lesson8code4.java
│ ├── lesson8code4.js
│ ├── lesson8code4.kt
│ ├── lesson8code4.py
│ └── lesson8code4.swift
│ └── lesson8code5
│ ├── lesson8code5.cpp
│ ├── lesson8code5.cs
│ ├── lesson8code5.go
│ ├── lesson8code5.java
│ ├── lesson8code5.js
│ ├── lesson8code5.kt
│ ├── lesson8code5.py
│ └── lesson8code5.swift
├── sprint6
├── By languages
│ ├── C#
│ │ ├── lesson11code2.cs
│ │ ├── lesson11code3.cs
│ │ ├── lesson4code1.cs
│ │ ├── lesson4code2.cs
│ │ ├── lesson4code3.cs
│ │ ├── lesson5code1.cs
│ │ ├── lesson6code1.cs
│ │ ├── lesson8code1.cs
│ │ └── lesson9code1.cs
│ ├── C++
│ │ ├── lesson11code2.cpp
│ │ ├── lesson11code3.cpp
│ │ ├── lesson4code1.cpp
│ │ ├── lesson4code2.cpp
│ │ ├── lesson4code3.cpp
│ │ ├── lesson5code1.cpp
│ │ ├── lesson6code1.cpp
│ │ ├── lesson8code1.cpp
│ │ └── lesson9code1.cpp
│ ├── JS
│ │ ├── lesson11code3.js
│ │ ├── lesson4code1.js
│ │ ├── lesson4code2.js
│ │ ├── lesson4code3.js
│ │ ├── lesson5code1.js
│ │ ├── lesson6code1.js
│ │ ├── lesson8code1.js
│ │ └── lesson9code1.js
│ ├── Java
│ │ ├── lesson11code2.java
│ │ ├── lesson11code3.java
│ │ ├── lesson4code1.java
│ │ ├── lesson4code2.java
│ │ ├── lesson4code3.java
│ │ ├── lesson5code1.java
│ │ ├── lesson6code1.java
│ │ ├── lesson8code1.java
│ │ └── lesson9code1.java
│ ├── go
│ │ ├── lesson11code3.go
│ │ ├── lesson4code1.go
│ │ ├── lesson4code2.go
│ │ ├── lesson4code3.go
│ │ ├── lesson5code1.go
│ │ ├── lesson6code1.go
│ │ ├── lesson8code1.go
│ │ └── lesson9code1.go
│ ├── kotlin
│ │ ├── lesson10code1.kt
│ │ ├── lesson11code1.kt
│ │ ├── lesson11code2.kt
│ │ ├── lesson11code3.kt
│ │ ├── lesson4code1.kt
│ │ ├── lesson4code2.kt
│ │ ├── lesson4code3.kt
│ │ ├── lesson5code1.kt
│ │ ├── lesson6code1.kt
│ │ ├── lesson8code1.kt
│ │ └── lesson9code1.kt
│ └── swift
│ │ ├── lesson11code2.swift
│ │ ├── lesson11code3.swift
│ │ ├── lesson4code1.swift
│ │ ├── lesson4code2.swift
│ │ ├── lesson4code3.swift
│ │ ├── lesson5code1.swift
│ │ ├── lesson6code1.swift
│ │ ├── lesson8code1.swift
│ │ └── lesson9code1.swift
└── By lessons
│ ├── lesson10code1
│ └── lesson10code1.kt
│ ├── lesson11code1
│ └── lesson11code1.kt
│ ├── lesson11code2
│ ├── lesson11code2.cpp
│ ├── lesson11code2.cs
│ ├── lesson11code2.java
│ ├── lesson11code2.kt
│ └── lesson11code2.swift
│ ├── lesson11code3
│ ├── lesson11code3.cpp
│ ├── lesson11code3.cs
│ ├── lesson11code3.go
│ ├── lesson11code3.java
│ ├── lesson11code3.js
│ ├── lesson11code3.kt
│ └── lesson11code3.swift
│ ├── lesson4code1
│ ├── lesson4code1.cpp
│ ├── lesson4code1.cs
│ ├── lesson4code1.go
│ ├── lesson4code1.java
│ ├── lesson4code1.js
│ ├── lesson4code1.kt
│ └── lesson4code1.swift
│ ├── lesson4code2
│ ├── lesson4code2.cpp
│ ├── lesson4code2.cs
│ ├── lesson4code2.go
│ ├── lesson4code2.java
│ ├── lesson4code2.js
│ ├── lesson4code2.kt
│ └── lesson4code2.swift
│ ├── lesson4code3
│ ├── lesson4code3.cpp
│ ├── lesson4code3.cs
│ ├── lesson4code3.go
│ ├── lesson4code3.java
│ ├── lesson4code3.js
│ ├── lesson4code3.kt
│ └── lesson4code3.swift
│ ├── lesson5code1
│ ├── lesson5code1.cpp
│ ├── lesson5code1.cs
│ ├── lesson5code1.go
│ ├── lesson5code1.java
│ ├── lesson5code1.js
│ ├── lesson5code1.kt
│ └── lesson5code1.swift
│ ├── lesson6code1
│ ├── lesson6code1.cpp
│ ├── lesson6code1.cs
│ ├── lesson6code1.go
│ ├── lesson6code1.java
│ ├── lesson6code1.js
│ ├── lesson6code1.kt
│ └── lesson6code1.swift
│ ├── lesson8code1
│ ├── lesson8code1.cpp
│ ├── lesson8code1.cs
│ ├── lesson8code1.go
│ ├── lesson8code1.java
│ ├── lesson8code1.js
│ ├── lesson8code1.kt
│ └── lesson8code1.swift
│ └── lesson9code1
│ ├── lesson9code1.cpp
│ ├── lesson9code1.cs
│ ├── lesson9code1.go
│ ├── lesson9code1.java
│ ├── lesson9code1.js
│ ├── lesson9code1.kt
│ └── lesson9code1.swift
├── sprint7
├── By languages
│ ├── C#
│ │ ├── lesson9code1.cs
│ │ ├── lesson9code2.cs
│ │ └── lesson9code3.cs
│ ├── C++
│ │ ├── lesson9code1.cpp
│ │ ├── lesson9code2.cpp
│ │ └── lesson9code3.cpp
│ ├── JS
│ │ ├── lesson9code1.js
│ │ ├── lesson9code2.js
│ │ └── lesson9code3.js
│ ├── Java
│ │ ├── lesson9code1.java
│ │ ├── lesson9code2.java
│ │ └── lesson9code3.java
│ ├── go
│ │ ├── lesson9code1.go
│ │ ├── lesson9code2.go
│ │ └── lesson9code3.go
│ ├── kotlin
│ │ ├── lesson9code1.kt
│ │ ├── lesson9code2.kt
│ │ └── lesson9code3.kt
│ ├── python
│ │ ├── lesson9code1.py
│ │ ├── lesson9code2.py
│ │ └── lesson9code3.py
│ └── swift
│ │ ├── lesson9code1.swift
│ │ ├── lesson9code2.swift
│ │ └── lesson9code3.swift
└── By lessons
│ ├── lesson9code1
│ ├── lesson9code1.cpp
│ ├── lesson9code1.cs
│ ├── lesson9code1.go
│ ├── lesson9code1.java
│ ├── lesson9code1.js
│ ├── lesson9code1.kt
│ ├── lesson9code1.py
│ └── lesson9code1.swift
│ ├── lesson9code2
│ ├── lesson9code2.cpp
│ ├── lesson9code2.cs
│ ├── lesson9code2.go
│ ├── lesson9code2.java
│ ├── lesson9code2.js
│ ├── lesson9code2.kt
│ ├── lesson9code2.py
│ └── lesson9code2.swift
│ └── lesson9code3
│ ├── lesson9code3.cpp
│ ├── lesson9code3.cs
│ ├── lesson9code3.go
│ ├── lesson9code3.java
│ ├── lesson9code3.js
│ ├── lesson9code3.kt
│ ├── lesson9code3.py
│ └── lesson9code3.swift
└── sprint8
├── By languages
├── C#
│ ├── lesson1code1.cs
│ ├── lesson2code1.cs
│ ├── lesson4code1.cs
│ ├── lesson4code2.cs
│ ├── lesson6code1.cs
│ ├── lesson6code2.cs
│ └── lesson7code1.cs
├── C++
│ ├── lesson1code1.cpp
│ ├── lesson2code1.cpp
│ ├── lesson4code1.cpp
│ ├── lesson4code2.cpp
│ ├── lesson6code1.cpp
│ ├── lesson6code2.cpp
│ └── lesson7code1.cpp
├── JS
│ ├── lesson1code1.js
│ ├── lesson2code1.js
│ ├── lesson4code1.js
│ ├── lesson4code2.js
│ ├── lesson6code1.js
│ ├── lesson6code2.js
│ └── lesson7code1.js
├── Java
│ ├── lesson1code1.java
│ ├── lesson2code1.java
│ ├── lesson4code1.java
│ ├── lesson4code2.java
│ ├── lesson6code1.java
│ ├── lesson6code2.java
│ └── lesson7code1.java
├── go
│ ├── lesson1code1.go
│ ├── lesson2code1.go
│ ├── lesson4code1.go
│ ├── lesson4code2.go
│ ├── lesson6code1.go
│ ├── lesson6code2.go
│ └── lesson7code1.go
├── kotlin
│ ├── lesson1code1.kt
│ ├── lesson2code1.kt
│ ├── lesson4code1.kt
│ ├── lesson4code2.kt
│ ├── lesson6code1.kt
│ ├── lesson6code2.kt
│ └── lesson7code1.kt
├── python
│ ├── lesson1code1.py
│ ├── lesson2code1.py
│ ├── lesson4code1.py
│ └── lesson4code2.py
└── swift
│ ├── lesson1code1.swift
│ ├── lesson2code1.swift
│ ├── lesson4code1.swift
│ ├── lesson4code2.swift
│ ├── lesson6code1.swift
│ ├── lesson6code2.swift
│ └── lesson7code1.swift
└── By lessons
├── lesson1code1
├── lesson1code1.cpp
├── lesson1code1.cs
├── lesson1code1.go
├── lesson1code1.java
├── lesson1code1.js
├── lesson1code1.kt
├── lesson1code1.py
└── lesson1code1.swift
├── lesson2code1
├── lesson2code1.cpp
├── lesson2code1.cs
├── lesson2code1.go
├── lesson2code1.java
├── lesson2code1.js
├── lesson2code1.kt
├── lesson2code1.py
└── lesson2code1.swift
├── lesson4code1
├── lesson4code1.cpp
├── lesson4code1.cs
├── lesson4code1.go
├── lesson4code1.java
├── lesson4code1.js
├── lesson4code1.kt
├── lesson4code1.py
└── lesson4code1.swift
├── lesson4code2
├── lesson4code2.cpp
├── lesson4code2.cs
├── lesson4code2.go
├── lesson4code2.java
├── lesson4code2.js
├── lesson4code2.kt
├── lesson4code2.py
└── lesson4code2.swift
├── lesson6code1
├── lesson6code1.cpp
├── lesson6code1.cs
├── lesson6code1.go
├── lesson6code1.java
├── lesson6code1.js
├── lesson6code1.kt
└── lesson6code1.swift
├── lesson6code2
├── lesson6code2.cpp
├── lesson6code2.cs
├── lesson6code2.go
├── lesson6code2.java
├── lesson6code2.js
├── lesson6code2.kt
└── lesson6code2.swift
└── lesson7code1
├── lesson7code1.cpp
├── lesson7code1.cs
├── lesson7code1.go
├── lesson7code1.java
├── lesson7code1.js
├── lesson7code1.kt
└── lesson7code1.swift
/.idea/.gitignore:
--------------------------------------------------------------------------------
1 | # Default ignored files
2 | /shelf/
3 | /workspace.xml
4 | # Editor-based HTTP Client requests
5 | /httpRequests/
6 | # Datasource local storage ignored files
7 | /dataSources/
8 | /dataSources.local.xml
9 |
--------------------------------------------------------------------------------
/.idea/algos.iml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
--------------------------------------------------------------------------------
/.idea/modules.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
--------------------------------------------------------------------------------
/.idea/vcs.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
--------------------------------------------------------------------------------
/sprint1/By languages/C#/lesson10code1.cs:
--------------------------------------------------------------------------------
1 | public static int Solve(List array)
2 | {
3 | int maximal_sum = 0; // Сумма пустого префикса равна 0
4 |
5 | for (int i = 0; i < array.Count; i++)
6 | {
7 | int current_sum = array.GetRange(0, i + 1).Sum();
8 |
9 | if (maximal_sum < current_sum)
10 | {
11 | maximal_sum = current_sum;
12 | }
13 | }
14 |
15 | return maximal_sum;
16 | }
17 |
--------------------------------------------------------------------------------
/sprint1/By languages/C#/lesson2code1.cs:
--------------------------------------------------------------------------------
1 | public static int FindElement(int[] numbers, int x)
2 | {
3 | for (int i = 0; i < numbers.Length; i++) // проходим по всем элементам массива
4 | {
5 | if (numbers[i] == x) // сравниваем их с иксом
6 | {
7 | return i; // если нашли - возвращаем индекс
8 | }
9 | }
10 | return -1; // если не нашли - возвращаем -1
11 | }
12 |
--------------------------------------------------------------------------------
/sprint1/By languages/C#/lesson4code1.cs:
--------------------------------------------------------------------------------
1 | using System;
2 |
3 | public class Program
4 | {
5 | public static void Main()
6 | {
7 | int n = int.Parse(Console.ReadLine());
8 | Console.WriteLine(42 * n + 15);
9 | }
10 | }
11 |
--------------------------------------------------------------------------------
/sprint1/By languages/C#/lesson5code1.cs:
--------------------------------------------------------------------------------
1 | int[] visitors = {0, 2, 3, 2, 0, 4, 1, 1, 2};
2 | int[] entriesByVisitor = new int[5];
3 | int bestVisitor = 0;
4 |
5 | foreach (int visitor in visitors)
6 | {
7 | entriesByVisitor[visitor]++;
8 | if (entriesByVisitor[visitor] > entriesByVisitor[bestVisitor])
9 | {
10 | bestVisitor = visitor;
11 | }
12 | }
13 |
14 | Console.WriteLine(bestVisitor);
15 |
--------------------------------------------------------------------------------
/sprint1/By languages/C#/lesson6code1.cs:
--------------------------------------------------------------------------------
1 | int cgCount = 0;
2 | for (int position = left; position < right; position++)
3 | {
4 | if ((sequence[position] == 'C') || (sequence[position] == 'G'))
5 | {
6 | cgCount++;
7 | }
8 | }
9 |
10 | Console.WriteLine(cgCount);
11 |
--------------------------------------------------------------------------------
/sprint1/By languages/C#/lesson6code2.cs:
--------------------------------------------------------------------------------
1 | List cumulativeSums = new List() { 0 };
2 | int cgCount = 0;
3 |
4 | for (int position = 0; position < sequence.Length; position++)
5 | {
6 | if ((sequence[position] == 'C') || (sequence[position] == 'G'))
7 | {
8 | cgCount++;
9 | }
10 |
11 | cumulativeSums.Add(cgCount);
12 | }
13 |
14 | Console.WriteLine(cumulativeSums[right] - cumulativeSums[left]);
15 |
--------------------------------------------------------------------------------
/sprint1/By languages/C#/lesson7code1.cs:
--------------------------------------------------------------------------------
1 | public static bool IsPrime(int n)
2 | {
3 | if (n == 1)
4 | {
5 | return false;
6 | }
7 |
8 | int i = 2;
9 |
10 | while (i < n)
11 | {
12 | if (n % i == 0)
13 | {
14 | return false;
15 | }
16 |
17 | i++;
18 | }
19 |
20 | return true;
21 | }
22 |
--------------------------------------------------------------------------------
/sprint1/By languages/C#/lesson7code2.cs:
--------------------------------------------------------------------------------
1 | public static bool IsPrime(int n)
2 | {
3 | if (n == 1)
4 | {
5 | return false;
6 | }
7 |
8 | int i = 2;
9 |
10 | while (i * i <= n)
11 | {
12 | if (n % i == 0)
13 | {
14 | return false;
15 | }
16 |
17 | i++;
18 | }
19 |
20 | return true;
21 | }
22 |
--------------------------------------------------------------------------------
/sprint1/By languages/C#/lesson7code3.cs:
--------------------------------------------------------------------------------
1 | public static List GetSmallerPrimes(int n)
2 | {
3 | List smallerPrimes = new List();
4 |
5 | for (int num = 2; num <= n; num++)
6 | {
7 | if (IsPrime(num))
8 | {
9 | smallerPrimes.Add(num);
10 | }
11 | }
12 |
13 | return smallerPrimes;
14 | }
15 |
--------------------------------------------------------------------------------
/sprint1/By languages/C++/lesson2code1.cpp:
--------------------------------------------------------------------------------
1 | int find_element(vector numbers, int x) {
2 | for (int i = 0; i < numbers.size(); i++) { // проходим по всем элементам массива
3 | if (numbers[i] == x) { // сравниваем их с иксом
4 | return i; // если нашли - возвращаем индекс
5 | }
6 | }
7 | return -1; // если не нашли - возвращаем -1
8 | }
9 |
--------------------------------------------------------------------------------
/sprint1/By languages/C++/lesson4code1.cpp:
--------------------------------------------------------------------------------
1 | #include
2 | using namespace std;
3 |
4 | int main() {
5 | int n;
6 | cin >> n;
7 | cout << 42 * n + 15 << endl;
8 | return 0;
9 | }
10 |
--------------------------------------------------------------------------------
/sprint1/By languages/C++/lesson7code1.cpp:
--------------------------------------------------------------------------------
1 | #include
2 | using namespace std;
3 |
4 | bool is_prime(int n) {
5 | if (n == 1) {
6 | return false;
7 | }
8 | int i = 2;
9 | while (i < n) {
10 | if (n % i == 0) {
11 | return false;
12 | }
13 | i++;
14 | }
15 | return true;
16 | }
--------------------------------------------------------------------------------
/sprint1/By languages/C++/lesson7code2.cpp:
--------------------------------------------------------------------------------
1 | #include
2 | using namespace std;
3 |
4 | bool is_prime(int n) {
5 | if (n == 1) {
6 | return false;
7 | }
8 | int i = 2;
9 | while (i * i <= n) {
10 | if (n % i == 0) {
11 | return false;
12 | }
13 | i++;
14 | }
15 | return true;
16 | }
--------------------------------------------------------------------------------
/sprint1/By languages/C++/lesson7code3.cpp:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 | using namespace std;
4 |
5 | vector get_smaller_primes(int n) {
6 | vector smaller_primes;
7 | for (int num = 2; num <= n; num++) {
8 | if (is_prime(num)) {
9 | smaller_primes.push_back(num);
10 | }
11 | }
12 | return smaller_primes;
13 | }
14 |
--------------------------------------------------------------------------------
/sprint1/By languages/JS/lesson10code1.js:
--------------------------------------------------------------------------------
1 | function solve(array) {
2 | let maximal_sum = 0; // Сумма пустого префикса равна 0
3 | for (let i = 0; i < array.length; i++) {
4 | let current_sum = array.slice(0, i + 1).reduce((a, b) => a + b, 0);
5 | if (maximal_sum < current_sum) {
6 | maximal_sum = current_sum;
7 | }
8 | }
9 | return maximal_sum;
10 | }
11 |
--------------------------------------------------------------------------------
/sprint1/By languages/JS/lesson4code1.js:
--------------------------------------------------------------------------------
1 | // Получаем целое число n из пользовательского ввода
2 | const n = parseInt(prompt('Введите целое число:'), 10);
3 |
4 | // Вычисляем результат и выводим его в консоль
5 | console.log(42 * n + 15);
6 |
--------------------------------------------------------------------------------
/sprint1/By languages/JS/lesson5code2.js:
--------------------------------------------------------------------------------
1 | const time_start = Date.now();
2 | let i = 0;
3 | while (i < 1000000000) {
4 | // Ничего не делаем
5 | i += 1;
6 | }
7 | const time_finish = Date.now();
8 | const time_span = (time_finish - time_start) / 1000; // переводим миллисекунды в секунды
9 | console.log(time_span, 'секунд');
10 |
--------------------------------------------------------------------------------
/sprint1/By languages/JS/lesson6code1.js:
--------------------------------------------------------------------------------
1 | let cg_count = 0;
2 | for (let position = left; position < right; position++) {
3 | if (sequence[position] === 'C' || sequence[position] === 'G') {
4 | cg_count++;
5 | }
6 | }
7 | console.log(cg_count);
8 |
--------------------------------------------------------------------------------
/sprint1/By languages/JS/lesson6code2.js:
--------------------------------------------------------------------------------
1 | const cumulative_sums = [0];
2 | let cg_count = 0;
3 | for (let position = 0; position < sequence.length; position++) {
4 | if (sequence[position] === 'C' || sequence[position] === 'G') {
5 | cg_count++;
6 | }
7 | cumulative_sums.push(cg_count);
8 | }
9 | console.log(cumulative_sums[right] - cumulative_sums[left]);
10 |
--------------------------------------------------------------------------------
/sprint1/By languages/JS/lesson7code1.js:
--------------------------------------------------------------------------------
1 | function is_prime(n) {
2 | if (n === 1) {
3 | return false;
4 | }
5 | let i = 2;
6 | while (i < n) {
7 | if (n % i === 0) {
8 | return false;
9 | }
10 | i++;
11 | }
12 | return true;
13 | }
14 |
--------------------------------------------------------------------------------
/sprint1/By languages/JS/lesson7code2.js:
--------------------------------------------------------------------------------
1 | function is_prime(n) {
2 | if (n === 1) {
3 | return false;
4 | }
5 | let i = 2;
6 | while (i * i <= n) {
7 | if (n % i === 0) {
8 | return false;
9 | }
10 | i++;
11 | }
12 | return true;
13 | }
14 |
--------------------------------------------------------------------------------
/sprint1/By languages/JS/lesson7code3.js:
--------------------------------------------------------------------------------
1 | function get_smaller_primes(n) {
2 | const smaller_primes = [];
3 | for (let num = 2; num <= n; num++) {
4 | if (is_prime(num)) {
5 | smaller_primes.push(num);
6 | }
7 | }
8 | return smaller_primes;
9 | }
10 |
--------------------------------------------------------------------------------
/sprint1/By languages/JS/lesson7code4.js:
--------------------------------------------------------------------------------
1 | function eratosthenes(n) {
2 | const numbers = new Array(n + 1).fill(true);
3 | numbers[0] = numbers[1] = false;
4 | for (let num = 2; num < n; num++) {
5 | if (numbers[num]) {
6 | for (let j = 2 * num; j <= n; j += num) {
7 | numbers[j] = false;
8 | }
9 | }
10 | }
11 | return numbers;
12 | }
13 |
--------------------------------------------------------------------------------
/sprint1/By languages/JS/lesson7code5.js:
--------------------------------------------------------------------------------
1 | function eratosthenes_effective(n) {
2 | const numbers = new Array(n + 1).fill(true);
3 | numbers[0] = numbers[1] = false;
4 | for (let num = 2; num < n; num++) {
5 | if (numbers[num]) {
6 | for (let j = num * num; j <= n; j += num) {
7 | numbers[j] = false;
8 | }
9 | }
10 | }
11 | return numbers;
12 | }
13 |
--------------------------------------------------------------------------------
/sprint1/By languages/Java/lesson2code1.java:
--------------------------------------------------------------------------------
1 | public static int findElement(int[] numbers, int x) {
2 | for (int i = 0; i < numbers.length; i++) { // проходим по всем элементам массива
3 | if (numbers[i] == x) { // сравниваем их с иксом
4 | return i; // если нашли - возвращаем индекс
5 | }
6 | }
7 | return -1; // если не нашли - возвращаем -1
8 | }
9 |
--------------------------------------------------------------------------------
/sprint1/By languages/Java/lesson4code1.java:
--------------------------------------------------------------------------------
1 | import java.util.Scanner;
2 |
3 | public class Main {
4 | public static void main(String[] args) {
5 | Scanner scanner = new Scanner(System.in);
6 | int n = scanner.nextInt();
7 | System.out.println(42 * n + 15);
8 | }
9 | }
10 |
--------------------------------------------------------------------------------
/sprint1/By languages/Java/lesson5code2.java:
--------------------------------------------------------------------------------
1 | long time_start = System.currentTimeMillis();
2 | long i = 0;
3 | while (i < 1000000000) {
4 | i++;
5 | }
6 | long time_finish = System.currentTimeMillis();
7 | long time_span = time_finish - time_start;
8 | System.out.println(time_span / 1000.0 + " seconds");
9 |
--------------------------------------------------------------------------------
/sprint1/By languages/Java/lesson6code1.java:
--------------------------------------------------------------------------------
1 | int[] cumulativeSums = new int[sequence.length() + 1];
2 | int cgCount = 0;
3 | for (int position = 0; position < sequence.length(); position++) {
4 | if (sequence.charAt(position) == 'C' || sequence.charAt(position) == 'G') {
5 | cgCount++;
6 | }
7 | cumulativeSums[position + 1] = cgCount;
8 | }
9 | System.out.println(cumulativeSums[right] - cumulativeSums[left]);
10 |
--------------------------------------------------------------------------------
/sprint1/By languages/Java/lesson6code2.java:
--------------------------------------------------------------------------------
1 | int[] cumulativeSums = new int[sequence.length() + 1];
2 | int cgCount = 0;
3 |
4 | for (int i = 0; i < sequence.length(); i++) {
5 | if (sequence.charAt(i) == 'C' || sequence.charAt(i) == 'G') {
6 | cgCount++;
7 | }
8 | cumulativeSums[i + 1] = cgCount;
9 | }
10 |
11 | System.out.println(cumulativeSums[right] - cumulativeSums[left]);
12 |
--------------------------------------------------------------------------------
/sprint1/By languages/Java/lesson7code1.java:
--------------------------------------------------------------------------------
1 | public static boolean isPrime(int n) {
2 | if (n == 1) {
3 | return false;
4 | }
5 | int i = 2;
6 | while (i < n) {
7 | if (n % i == 0) {
8 | return false;
9 | }
10 | i = i + 1;
11 | }
12 | return true;
13 | }
14 |
--------------------------------------------------------------------------------
/sprint1/By languages/Java/lesson7code2.java:
--------------------------------------------------------------------------------
1 | public static boolean isPrime(int n) {
2 | if (n == 1) {
3 | return false;
4 | }
5 | int i = 2;
6 | while (i * i <= n) {
7 | if (n % i == 0) {
8 | return false;
9 | }
10 | i = i + 1;
11 | }
12 | return true;
13 | }
14 |
--------------------------------------------------------------------------------
/sprint1/By languages/Java/lesson7code3.java:
--------------------------------------------------------------------------------
1 | public static List getSmallerPrimes(int n) {
2 | List smallerPrimes = new ArrayList<>();
3 | for (int num = 2; num <= n; num++) {
4 | if (isPrime(num)) {
5 | smallerPrimes.add(num);
6 | }
7 | }
8 | return smallerPrimes;
9 | }
10 |
--------------------------------------------------------------------------------
/sprint1/By languages/go/lesson10code1.cpp:
--------------------------------------------------------------------------------
1 | func solve(array []int) int {
2 | maximal_sum := 0 // Сумма пустого префикса равна 0
3 | for i := 0; i < len(array); i++ {
4 | current_sum := 0
5 | for j := 0; j <= i; j++ {
6 | current_sum += array[j]
7 | }
8 | if maximal_sum < current_sum {
9 | maximal_sum = current_sum
10 | }
11 | }
12 | return maximal_sum
13 | }
14 |
--------------------------------------------------------------------------------
/sprint1/By languages/go/lesson10code1.go:
--------------------------------------------------------------------------------
1 | func solve(array []int) int {
2 | maximal_sum := 0 // Сумма пустого префикса равна 0
3 | for i := 0; i < len(array); i++ {
4 | current_sum := 0
5 | for j := 0; j <= i; j++ {
6 | current_sum += array[j]
7 | }
8 | if maximal_sum < current_sum {
9 | maximal_sum = current_sum
10 | }
11 | }
12 | return maximal_sum
13 | }
14 |
--------------------------------------------------------------------------------
/sprint1/By languages/go/lesson2code1.cpp:
--------------------------------------------------------------------------------
1 | func findElement(numbers []int, x int) int {
2 | for i := 0; i < len(numbers); i++ { // проходим по всем элементам массива
3 | if numbers[i] == x { // сравниваем их с иксом
4 | return i // если нашли - возвращаем индекс
5 | }
6 | }
7 | return -1 // если не нашли - возвращаем -1
8 | }
--------------------------------------------------------------------------------
/sprint1/By languages/go/lesson2code1.go:
--------------------------------------------------------------------------------
1 | func findElement(numbers []int, x int) int {
2 | for i := 0; i < len(numbers); i++ { // проходим по всем элементам массива
3 | if numbers[i] == x { // сравниваем их с иксом
4 | return i // если нашли - возвращаем индекс
5 | }
6 | }
7 | return -1 // если не нашли - возвращаем -1
8 | }
--------------------------------------------------------------------------------
/sprint1/By languages/go/lesson4code1.cpp:
--------------------------------------------------------------------------------
1 | package main
2 |
3 | import "fmt"
4 |
5 | func main() {
6 | var n int
7 | fmt.Scanln(&n)
8 | fmt.Println(42*n + 15)
9 | }
--------------------------------------------------------------------------------
/sprint1/By languages/go/lesson4code1.go:
--------------------------------------------------------------------------------
1 | package main
2 |
3 | import "fmt"
4 |
5 | func main() {
6 | var n int
7 | fmt.Scanln(&n)
8 | fmt.Println(42*n + 15)
9 | }
--------------------------------------------------------------------------------
/sprint1/By languages/go/lesson5code2.cpp:
--------------------------------------------------------------------------------
1 | import "time"
2 |
3 | timeStart := time.Now()
4 | i := 0
5 | for i < 1000000000 {
6 | // Do nothing
7 | i++
8 | }
9 | timeFinish := time.Now()
10 | timeSpan := timeFinish.Sub(timeStart)
11 | fmt.Println(timeSpan, "seconds")
12 |
--------------------------------------------------------------------------------
/sprint1/By languages/go/lesson5code2.go:
--------------------------------------------------------------------------------
1 | import "time"
2 |
3 | timeStart := time.Now()
4 | i := 0
5 | for i < 1000000000 {
6 | // Do nothing
7 | i++
8 | }
9 | timeFinish := time.Now()
10 | timeSpan := timeFinish.Sub(timeStart)
11 | fmt.Println(timeSpan, "seconds")
12 |
--------------------------------------------------------------------------------
/sprint1/By languages/go/lesson6code1.cpp:
--------------------------------------------------------------------------------
1 | cgCount := 0
2 | for position := left; position < right; position++ {
3 | if sequence[position] == 'C' || sequence[position] == 'G' {
4 | cgCount++
5 | }
6 | }
7 | fmt.Println(cgCount)
8 |
--------------------------------------------------------------------------------
/sprint1/By languages/go/lesson6code1.go:
--------------------------------------------------------------------------------
1 | cgCount := 0
2 | for position := left; position < right; position++ {
3 | if sequence[position] == 'C' || sequence[position] == 'G' {
4 | cgCount++
5 | }
6 | }
7 | fmt.Println(cgCount)
8 |
--------------------------------------------------------------------------------
/sprint1/By languages/go/lesson6code2.cpp:
--------------------------------------------------------------------------------
1 | cumulativeSums := []int{0}
2 | cgCount := 0
3 | for position := 0; position < len(sequence); position++ {
4 | if sequence[position] == 'C' || sequence[position] == 'G' {
5 | cgCount++
6 | }
7 | cumulativeSums = append(cumulativeSums, cgCount)
8 | }
9 | fmt.Println(cumulativeSums[right] - cumulativeSums[left])
10 |
--------------------------------------------------------------------------------
/sprint1/By languages/go/lesson6code2.go:
--------------------------------------------------------------------------------
1 | cumulativeSums := []int{0}
2 | cgCount := 0
3 | for position := 0; position < len(sequence); position++ {
4 | if sequence[position] == 'C' || sequence[position] == 'G' {
5 | cgCount++
6 | }
7 | cumulativeSums = append(cumulativeSums, cgCount)
8 | }
9 | fmt.Println(cumulativeSums[right] - cumulativeSums[left])
10 |
--------------------------------------------------------------------------------
/sprint1/By languages/go/lesson7code1.cpp:
--------------------------------------------------------------------------------
1 | func isPrime(n int) bool {
2 | if n < 2 {
3 | return false
4 | }
5 | for i := 2; i < n; i++ {
6 | if n%i == 0 {
7 | return false
8 | }
9 | }
10 | return true
11 | }
--------------------------------------------------------------------------------
/sprint1/By languages/go/lesson7code1.go:
--------------------------------------------------------------------------------
1 | func isPrime(n int) bool {
2 | if n < 2 {
3 | return false
4 | }
5 | for i := 2; i < n; i++ {
6 | if n%i == 0 {
7 | return false
8 | }
9 | }
10 | return true
11 | }
--------------------------------------------------------------------------------
/sprint1/By languages/go/lesson7code2.cpp:
--------------------------------------------------------------------------------
1 | func isPrime(n int) bool {
2 | if n < 2 {
3 | return false
4 | }
5 | for i := 2; i*i <= n; i++ {
6 | if n%i == 0 {
7 | return false
8 | }
9 | }
10 | return true
11 | }
--------------------------------------------------------------------------------
/sprint1/By languages/go/lesson7code2.go:
--------------------------------------------------------------------------------
1 | func isPrime(n int) bool {
2 | if n < 2 {
3 | return false
4 | }
5 | for i := 2; i*i <= n; i++ {
6 | if n%i == 0 {
7 | return false
8 | }
9 | }
10 | return true
11 | }
--------------------------------------------------------------------------------
/sprint1/By languages/kotlin/lesson10code1.kt:
--------------------------------------------------------------------------------
1 | fun solve(array: List): Int {
2 | var maximalSum = 0
3 | for (i in 0 until array.size) {
4 | val currentSum = array.subList(0, i + 1).sum()
5 | if (maximalSum < currentSum) {
6 | maximalSum = currentSum
7 | }
8 | }
9 | return maximalSum
10 | }
11 |
--------------------------------------------------------------------------------
/sprint1/By languages/kotlin/lesson2code1.kt:
--------------------------------------------------------------------------------
1 | fun findElement(numbers: List, x: Int): Int {
2 | for (i in numbers.indices) { // проходим по всем элементам массива
3 | if (numbers[i] == x) { // сравниваем их с иксом
4 | return i // если нашли - возвращаем индекс
5 | }
6 | }
7 | return -1 // если не нашли - возвращаем -1
8 | }
--------------------------------------------------------------------------------
/sprint1/By languages/kotlin/lesson4code1.kt:
--------------------------------------------------------------------------------
1 | val n = readLine()!!.toInt()
2 | println(42 * n + 15)
--------------------------------------------------------------------------------
/sprint1/By languages/kotlin/lesson5code2.kt:
--------------------------------------------------------------------------------
1 | import kotlin.system.measureTimeMillis
2 |
3 | val timeSpan = measureTimeMillis {
4 | var i = 0
5 | while (i < 1000000000) {
6 | // Do nothing
7 | i++
8 | }
9 | }
10 |
11 | println("$timeSpan milliseconds")
--------------------------------------------------------------------------------
/sprint1/By languages/kotlin/lesson6code1.kt:
--------------------------------------------------------------------------------
1 | var cgCount = 0
2 | for (position in left until right) {
3 | if (sequence[position] == 'C' || sequence[position] == 'G') {
4 | cgCount++
5 | }
6 | }
7 |
8 | println(cgCount)
--------------------------------------------------------------------------------
/sprint1/By languages/kotlin/lesson6code2.kt:
--------------------------------------------------------------------------------
1 | Copy code
2 | var cumulativeSums = mutableListOf(0)
3 | var cgCount = 0
4 | for (position in 0 until sequence.length) {
5 | if (sequence[position] == 'C' || sequence[position] == 'G') {
6 | cgCount++
7 | }
8 | cumulativeSums.add(cgCount)
9 | }
10 |
11 | println(cumulativeSums[right] - cumulativeSums[left])
12 |
--------------------------------------------------------------------------------
/sprint1/By languages/kotlin/lesson7code1.kt:
--------------------------------------------------------------------------------
1 | fun isPrime(n: Int): Boolean {
2 | if (n == 1) return false
3 | var i = 2
4 | while (i < n) {
5 | if (n % i == 0) return false
6 | i++
7 | }
8 | return true
9 | }
10 |
--------------------------------------------------------------------------------
/sprint1/By languages/kotlin/lesson7code2.kt:
--------------------------------------------------------------------------------
1 | fun isPrime(n: Int): Boolean {
2 | if (n == 1) return false
3 | var i = 2
4 | while (i * i <= n) {
5 | if (n % i == 0) return false
6 | i++
7 | }
8 | return true
9 | }
10 |
--------------------------------------------------------------------------------
/sprint1/By languages/kotlin/lesson7code3.kt:
--------------------------------------------------------------------------------
1 | fun getSmallerPrimes(n: Int): List {
2 | val smallerPrimes = mutableListOf()
3 | for (num in 2..n) {
4 | if (isPrime(num)) {
5 | smallerPrimes.add(num)
6 | }
7 | }
8 | return smallerPrimes
9 | }
10 |
--------------------------------------------------------------------------------
/sprint1/By languages/kotlin/lesson7code4.kt:
--------------------------------------------------------------------------------
1 | fun eratosthenes(n: Int): BooleanArray {
2 | val numbers = BooleanArray(n + 1) { true }
3 | numbers[0] = false
4 | numbers[1] = false
5 | for (num in 2..n) {
6 | if (numbers[num]) {
7 | for (j in (2 * num)..n step num) {
8 | numbers[j] = false
9 | }
10 | }
11 | }
12 | return numbers
13 | }
14 |
--------------------------------------------------------------------------------
/sprint1/By languages/kotlin/lesson7code5.kt:
--------------------------------------------------------------------------------
1 | fun eratosthenesEffective(n: Int): BooleanArray {
2 | val numbers = BooleanArray(n + 1) { true }
3 | numbers[0] = false
4 | numbers[1] = false
5 | for (num in 2..n) {
6 | if (numbers[num]) {
7 | for (j in (num * num)..n step num) {
8 | numbers[j] = false
9 | }
10 | }
11 | }
12 | return numbers
13 | }
14 |
--------------------------------------------------------------------------------
/sprint1/By languages/python/lesson10code1.py:
--------------------------------------------------------------------------------
1 | def solve(array: List[int]) -> int:
2 | maximal_sum = 0 # Сумма пустого префикса равна 0
3 | for i in range(len(array)):
4 | current_sum = sum[array[0: i + 1]]
5 | if maximal_sum < current_sum:
6 | maximal_sum = current_sum
7 | return maximal_sum
8 |
--------------------------------------------------------------------------------
/sprint1/By languages/python/lesson2code1.py:
--------------------------------------------------------------------------------
1 | def find_element(numbers, x):
2 | for i in range(len(numbers)): # проходим по всем элементам массива
3 | if numbers[i] == x: # сравниваем их с иксом
4 | return i # если нашли - возвращаем индекс
5 | return -1 # если не нашли - возвращаем -1
--------------------------------------------------------------------------------
/sprint1/By languages/python/lesson4code1.py:
--------------------------------------------------------------------------------
1 | n = int(input())
2 | print(42 * n + 15)
--------------------------------------------------------------------------------
/sprint1/By languages/python/lesson5code2.py:
--------------------------------------------------------------------------------
1 | import time
2 |
3 | time_start = time.time()
4 | i = 0
5 | while i < 1000000000:
6 | # Do nothing
7 | i += 1
8 |
9 | time_finish = time.time()
10 | time_span = time_finish - time_start
11 | print(time_span, 'seconds')
--------------------------------------------------------------------------------
/sprint1/By languages/python/lesson6code1.py:
--------------------------------------------------------------------------------
1 | cg_count = 0
2 | for position in range(left, right):
3 | if (sequence[position] == 'C') or (sequence[position] == 'G'):
4 | cg_count += 1
5 |
6 | print(cg_count)
7 |
--------------------------------------------------------------------------------
/sprint1/By languages/python/lesson6code2.py:
--------------------------------------------------------------------------------
1 | cumulative_sums = [0]
2 | cg_count = 0
3 | for position in range(0, len(sequence)):
4 | if (sequence[position] == 'C') or (sequence[position] == 'G'):
5 | cg_count += 1
6 | cumulative_sums.append(cg_count)
7 |
8 | print(cumulative_sums[right] - cumulative_sums[left])
9 |
--------------------------------------------------------------------------------
/sprint1/By languages/python/lesson7code1.py:
--------------------------------------------------------------------------------
1 | def is_prime(n):
2 | if n == 1:
3 | return False
4 | i = 2
5 | while i < n:
6 | if n % i == 0:
7 | return False
8 | i = i + 1
9 | return True
10 |
--------------------------------------------------------------------------------
/sprint1/By languages/python/lesson7code2.py:
--------------------------------------------------------------------------------
1 | def is_prime(n):
2 | if n == 1:
3 | return False
4 | i = 2
5 | while i * i <= n:
6 | if n % i == 0:
7 | return False
8 | i = i + 1
9 | return True
10 |
--------------------------------------------------------------------------------
/sprint1/By languages/python/lesson7code3.py:
--------------------------------------------------------------------------------
1 | def get_smaller_primes(n):
2 | smaller_primes = []
3 | for num in range(2, n + 1):
4 | if is_prime(num):
5 | smaller_primes.append(num)
6 | return smaller_primes
7 |
--------------------------------------------------------------------------------
/sprint1/By languages/python/lesson7code4.py:
--------------------------------------------------------------------------------
1 | def eratosthenes(n):
2 | numbers = list(range(n + 1))
3 | numbers[0] = numbers[1] = False
4 | for num in range(2, n):
5 | if numbers[num]:
6 | for j in range(2 * num, n + 1, num):
7 | numbers[j] = False
8 | return numbers
9 |
--------------------------------------------------------------------------------
/sprint1/By languages/python/lesson7code5.py:
--------------------------------------------------------------------------------
1 | def eratosthenes_effective(n):
2 | numbers = list(range(n + 1))
3 | numbers[0] = numbers[1] = False
4 | for num in range(2, n):
5 | if numbers[num]:
6 | for j in range(num * num, n + 1, num):
7 | numbers[j] = False
8 | return numbers
9 |
--------------------------------------------------------------------------------
/sprint1/By languages/python/lesson7code6.py:
--------------------------------------------------------------------------------
1 | def get_least_primes_linear(n):
2 | lp = [0] * (n + 1)
3 | primes = []
4 | for i in range(2, n + 1):
5 | if lp[i] == 0:
6 | lp[i] = i
7 | primes.append(i)
8 | for p in primes:
9 | x = p * i
10 | if (p > lp[i]) or (x > n):
11 | break
12 | lp[x] = p
13 | return primes, lp
14 |
--------------------------------------------------------------------------------
/sprint1/By languages/swift/lesson10code1.swift:
--------------------------------------------------------------------------------
1 | func solve(array: [Int]) -> Int {
2 | var maximalSum = 0 // Сумма пустого префикса равна 0
3 | for i in 0.. Int {
2 | for i in 0.. Bool {
2 | if n == 1 {
3 | return false
4 | }
5 | var i = 2
6 | while i < n {
7 | if n % i == 0 {
8 | return false
9 | }
10 | i += 1
11 | }
12 | return true
13 | }
14 |
--------------------------------------------------------------------------------
/sprint1/By languages/swift/lesson7code2.swift:
--------------------------------------------------------------------------------
1 | func isPrime(_ n: Int) -> Bool {
2 | if n == 1 {
3 | return false
4 | }
5 | var i = 2
6 | while i * i <= n {
7 | if n % i == 0 {
8 | return false
9 | }
10 | i += 1
11 | }
12 | return true
13 | }
--------------------------------------------------------------------------------
/sprint1/By languages/swift/lesson7code3.swift:
--------------------------------------------------------------------------------
1 | func getSmallerPrimes(_ n: Int) -> [Int] {
2 | var smallerPrimes = [Int]()
3 | for num in 2...n {
4 | if isPrime(num) {
5 | smallerPrimes.append(num)
6 | }
7 | }
8 | return smallerPrimes
9 | }
--------------------------------------------------------------------------------
/sprint1/By lessons/lesson10code1/lesson10code1.go:
--------------------------------------------------------------------------------
1 | func solve(array []int) int {
2 | maximal_sum := 0 // Сумма пустого префикса равна 0
3 | for i := 0; i < len(array); i++ {
4 | current_sum := 0
5 | for j := 0; j <= i; j++ {
6 | current_sum += array[j]
7 | }
8 | if maximal_sum < current_sum {
9 | maximal_sum = current_sum
10 | }
11 | }
12 | return maximal_sum
13 | }
14 |
--------------------------------------------------------------------------------
/sprint1/By lessons/lesson10code1/lesson10code1.js:
--------------------------------------------------------------------------------
1 | function solve(array) {
2 | let maximal_sum = 0; // Сумма пустого префикса равна 0
3 | for (let i = 0; i < array.length; i++) {
4 | let current_sum = array.slice(0, i + 1).reduce((a, b) => a + b, 0);
5 | if (maximal_sum < current_sum) {
6 | maximal_sum = current_sum;
7 | }
8 | }
9 | return maximal_sum;
10 | }
11 |
--------------------------------------------------------------------------------
/sprint1/By lessons/lesson10code1/lesson10code1.kt:
--------------------------------------------------------------------------------
1 | fun solve(array: List): Int {
2 | var maximalSum = 0
3 | for (i in 0 until array.size) {
4 | val currentSum = array.subList(0, i + 1).sum()
5 | if (maximalSum < currentSum) {
6 | maximalSum = currentSum
7 | }
8 | }
9 | return maximalSum
10 | }
11 |
--------------------------------------------------------------------------------
/sprint1/By lessons/lesson10code1/lesson10code1.py:
--------------------------------------------------------------------------------
1 | def solve(array: List[int]) -> int:
2 | maximal_sum = 0 # Сумма пустого префикса равна 0
3 | for i in range(len(array)):
4 | current_sum = sum[array[0: i + 1]]
5 | if maximal_sum < current_sum:
6 | maximal_sum = current_sum
7 | return maximal_sum
8 |
--------------------------------------------------------------------------------
/sprint1/By lessons/lesson10code1/lesson10code1.swift:
--------------------------------------------------------------------------------
1 | func solve(array: [Int]) -> Int {
2 | var maximalSum = 0 // Сумма пустого префикса равна 0
3 | for i in 0.. numbers, int x) {
2 | for (int i = 0; i < numbers.size(); i++) { // проходим по всем элементам массива
3 | if (numbers[i] == x) { // сравниваем их с иксом
4 | return i; // если нашли - возвращаем индекс
5 | }
6 | }
7 | return -1; // если не нашли - возвращаем -1
8 | }
9 |
--------------------------------------------------------------------------------
/sprint1/By lessons/lesson2code1/lesson2code1.cs:
--------------------------------------------------------------------------------
1 | public static int FindElement(int[] numbers, int x)
2 | {
3 | for (int i = 0; i < numbers.Length; i++) // проходим по всем элементам массива
4 | {
5 | if (numbers[i] == x) // сравниваем их с иксом
6 | {
7 | return i; // если нашли - возвращаем индекс
8 | }
9 | }
10 | return -1; // если не нашли - возвращаем -1
11 | }
12 |
--------------------------------------------------------------------------------
/sprint1/By lessons/lesson2code1/lesson2code1.go:
--------------------------------------------------------------------------------
1 | func findElement(numbers []int, x int) int {
2 | for i := 0; i < len(numbers); i++ { // проходим по всем элементам массива
3 | if numbers[i] == x { // сравниваем их с иксом
4 | return i // если нашли - возвращаем индекс
5 | }
6 | }
7 | return -1 // если не нашли - возвращаем -1
8 | }
--------------------------------------------------------------------------------
/sprint1/By lessons/lesson2code1/lesson2code1.java:
--------------------------------------------------------------------------------
1 | public static int findElement(int[] numbers, int x) {
2 | for (int i = 0; i < numbers.length; i++) { // проходим по всем элементам массива
3 | if (numbers[i] == x) { // сравниваем их с иксом
4 | return i; // если нашли - возвращаем индекс
5 | }
6 | }
7 | return -1; // если не нашли - возвращаем -1
8 | }
9 |
--------------------------------------------------------------------------------
/sprint1/By lessons/lesson2code1/lesson2code1.kt:
--------------------------------------------------------------------------------
1 | fun findElement(numbers: List, x: Int): Int {
2 | for (i in numbers.indices) { // проходим по всем элементам массива
3 | if (numbers[i] == x) { // сравниваем их с иксом
4 | return i // если нашли - возвращаем индекс
5 | }
6 | }
7 | return -1 // если не нашли - возвращаем -1
8 | }
--------------------------------------------------------------------------------
/sprint1/By lessons/lesson2code1/lesson2code1.py:
--------------------------------------------------------------------------------
1 | def find_element(numbers, x):
2 | for i in range(len(numbers)): # проходим по всем элементам массива
3 | if numbers[i] == x: # сравниваем их с иксом
4 | return i # если нашли - возвращаем индекс
5 | return -1 # если не нашли - возвращаем -1
--------------------------------------------------------------------------------
/sprint1/By lessons/lesson2code1/lesson2code1.swift:
--------------------------------------------------------------------------------
1 | func findElement(in numbers: [Int], x: Int) -> Int {
2 | for i in 0..
2 | using namespace std;
3 |
4 | int main() {
5 | int n;
6 | cin >> n;
7 | cout << 42 * n + 15 << endl;
8 | return 0;
9 | }
10 |
--------------------------------------------------------------------------------
/sprint1/By lessons/lesson4code1/lesson4code1.cs:
--------------------------------------------------------------------------------
1 | using System;
2 |
3 | public class Program
4 | {
5 | public static void Main()
6 | {
7 | int n = int.Parse(Console.ReadLine());
8 | Console.WriteLine(42 * n + 15);
9 | }
10 | }
11 |
--------------------------------------------------------------------------------
/sprint1/By lessons/lesson4code1/lesson4code1.go:
--------------------------------------------------------------------------------
1 | package main
2 |
3 | import "fmt"
4 |
5 | func main() {
6 | var n int
7 | fmt.Scanln(&n)
8 | fmt.Println(42*n + 15)
9 | }
--------------------------------------------------------------------------------
/sprint1/By lessons/lesson4code1/lesson4code1.java:
--------------------------------------------------------------------------------
1 | import java.util.Scanner;
2 |
3 | public class Main {
4 | public static void main(String[] args) {
5 | Scanner scanner = new Scanner(System.in);
6 | int n = scanner.nextInt();
7 | System.out.println(42 * n + 15);
8 | }
9 | }
10 |
--------------------------------------------------------------------------------
/sprint1/By lessons/lesson4code1/lesson4code1.js:
--------------------------------------------------------------------------------
1 | // Получаем целое число n из пользовательского ввода
2 | const n = parseInt(prompt('Введите целое число:'), 10);
3 |
4 | // Вычисляем результат и выводим его в консоль
5 | console.log(42 * n + 15);
6 |
--------------------------------------------------------------------------------
/sprint1/By lessons/lesson4code1/lesson4code1.kt:
--------------------------------------------------------------------------------
1 | val n = readLine()!!.toInt()
2 | println(42 * n + 15)
--------------------------------------------------------------------------------
/sprint1/By lessons/lesson4code1/lesson4code1.py:
--------------------------------------------------------------------------------
1 | n = int(input())
2 | print(42 * n + 15)
--------------------------------------------------------------------------------
/sprint1/By lessons/lesson4code1/lesson4code1.swift:
--------------------------------------------------------------------------------
1 | import Foundation
2 |
3 | // Ввод числа с клавиатуры
4 | if let input = readLine(), let n = Int(input) {
5 | // Вычисление и вывод результата
6 | let result = 42 * n + 15
7 | print(result)
8 | } else {
9 | print("Некорректный ввод")
10 | }
--------------------------------------------------------------------------------
/sprint1/By lessons/lesson5code1/lesson5code1.cs:
--------------------------------------------------------------------------------
1 | int[] visitors = {0, 2, 3, 2, 0, 4, 1, 1, 2};
2 | int[] entriesByVisitor = new int[5];
3 | int bestVisitor = 0;
4 |
5 | foreach (int visitor in visitors)
6 | {
7 | entriesByVisitor[visitor]++;
8 | if (entriesByVisitor[visitor] > entriesByVisitor[bestVisitor])
9 | {
10 | bestVisitor = visitor;
11 | }
12 | }
13 |
14 | Console.WriteLine(bestVisitor);
15 |
--------------------------------------------------------------------------------
/sprint1/By lessons/lesson5code2/lesson5code2.go:
--------------------------------------------------------------------------------
1 | import "time"
2 |
3 | timeStart := time.Now()
4 | i := 0
5 | for i < 1000000000 {
6 | // Do nothing
7 | i++
8 | }
9 | timeFinish := time.Now()
10 | timeSpan := timeFinish.Sub(timeStart)
11 | fmt.Println(timeSpan, "seconds")
12 |
--------------------------------------------------------------------------------
/sprint1/By lessons/lesson5code2/lesson5code2.java:
--------------------------------------------------------------------------------
1 | long time_start = System.currentTimeMillis();
2 | long i = 0;
3 | while (i < 1000000000) {
4 | i++;
5 | }
6 | long time_finish = System.currentTimeMillis();
7 | long time_span = time_finish - time_start;
8 | System.out.println(time_span / 1000.0 + " seconds");
9 |
--------------------------------------------------------------------------------
/sprint1/By lessons/lesson5code2/lesson5code2.js:
--------------------------------------------------------------------------------
1 | const time_start = Date.now();
2 | let i = 0;
3 | while (i < 1000000000) {
4 | // Ничего не делаем
5 | i += 1;
6 | }
7 | const time_finish = Date.now();
8 | const time_span = (time_finish - time_start) / 1000; // переводим миллисекунды в секунды
9 | console.log(time_span, 'секунд');
10 |
--------------------------------------------------------------------------------
/sprint1/By lessons/lesson5code2/lesson5code2.kt:
--------------------------------------------------------------------------------
1 | import kotlin.system.measureTimeMillis
2 |
3 | val timeSpan = measureTimeMillis {
4 | var i = 0
5 | while (i < 1000000000) {
6 | // Do nothing
7 | i++
8 | }
9 | }
10 |
11 | println("$timeSpan milliseconds")
--------------------------------------------------------------------------------
/sprint1/By lessons/lesson5code2/lesson5code2.py:
--------------------------------------------------------------------------------
1 | import time
2 |
3 | time_start = time.time()
4 | i = 0
5 | while i < 1000000000:
6 | # Do nothing
7 | i += 1
8 |
9 | time_finish = time.time()
10 | time_span = time_finish - time_start
11 | print(time_span, 'seconds')
--------------------------------------------------------------------------------
/sprint1/By lessons/lesson5code2/lesson5code2.swift:
--------------------------------------------------------------------------------
1 | import Foundation
2 |
3 | let timeStart = Date().timeIntervalSince1970
4 | var i = 0
5 | while i < 1_000_000_000 {
6 | // Do nothing
7 | i += 1
8 | }
9 |
10 | let timeFinish = Date().timeIntervalSince1970
11 | let timeSpan = timeFinish - timeStart
12 | print("\(timeSpan) seconds")
--------------------------------------------------------------------------------
/sprint1/By lessons/lesson6code1/lesson6code1.cs:
--------------------------------------------------------------------------------
1 | int cgCount = 0;
2 | for (int position = left; position < right; position++)
3 | {
4 | if ((sequence[position] == 'C') || (sequence[position] == 'G'))
5 | {
6 | cgCount++;
7 | }
8 | }
9 |
10 | Console.WriteLine(cgCount);
11 |
--------------------------------------------------------------------------------
/sprint1/By lessons/lesson6code1/lesson6code1.go:
--------------------------------------------------------------------------------
1 | cgCount := 0
2 | for position := left; position < right; position++ {
3 | if sequence[position] == 'C' || sequence[position] == 'G' {
4 | cgCount++
5 | }
6 | }
7 | fmt.Println(cgCount)
8 |
--------------------------------------------------------------------------------
/sprint1/By lessons/lesson6code1/lesson6code1.java:
--------------------------------------------------------------------------------
1 | int[] cumulativeSums = new int[sequence.length() + 1];
2 | int cgCount = 0;
3 | for (int position = 0; position < sequence.length(); position++) {
4 | if (sequence.charAt(position) == 'C' || sequence.charAt(position) == 'G') {
5 | cgCount++;
6 | }
7 | cumulativeSums[position + 1] = cgCount;
8 | }
9 | System.out.println(cumulativeSums[right] - cumulativeSums[left]);
10 |
--------------------------------------------------------------------------------
/sprint1/By lessons/lesson6code1/lesson6code1.js:
--------------------------------------------------------------------------------
1 | let cg_count = 0;
2 | for (let position = left; position < right; position++) {
3 | if (sequence[position] === 'C' || sequence[position] === 'G') {
4 | cg_count++;
5 | }
6 | }
7 | console.log(cg_count);
8 |
--------------------------------------------------------------------------------
/sprint1/By lessons/lesson6code1/lesson6code1.kt:
--------------------------------------------------------------------------------
1 | var cgCount = 0
2 | for (position in left until right) {
3 | if (sequence[position] == 'C' || sequence[position] == 'G') {
4 | cgCount++
5 | }
6 | }
7 |
8 | println(cgCount)
--------------------------------------------------------------------------------
/sprint1/By lessons/lesson6code1/lesson6code1.py:
--------------------------------------------------------------------------------
1 | cg_count = 0
2 | for position in range(left, right):
3 | if (sequence[position] == 'C') or (sequence[position] == 'G'):
4 | cg_count += 1
5 |
6 | print(cg_count)
7 |
--------------------------------------------------------------------------------
/sprint1/By lessons/lesson6code1/lesson6code1.swift:
--------------------------------------------------------------------------------
1 | var cgCount = 0
2 | let sequence = "ACGTACGGTCGA"
3 | let left = 0
4 | let right = sequence.count
5 |
6 | for position in left.. cumulativeSums = new List() { 0 };
2 | int cgCount = 0;
3 |
4 | for (int position = 0; position < sequence.Length; position++)
5 | {
6 | if ((sequence[position] == 'C') || (sequence[position] == 'G'))
7 | {
8 | cgCount++;
9 | }
10 |
11 | cumulativeSums.Add(cgCount);
12 | }
13 |
14 | Console.WriteLine(cumulativeSums[right] - cumulativeSums[left]);
15 |
--------------------------------------------------------------------------------
/sprint1/By lessons/lesson6code2/lesson6code2.go:
--------------------------------------------------------------------------------
1 | cumulativeSums := []int{0}
2 | cgCount := 0
3 | for position := 0; position < len(sequence); position++ {
4 | if sequence[position] == 'C' || sequence[position] == 'G' {
5 | cgCount++
6 | }
7 | cumulativeSums = append(cumulativeSums, cgCount)
8 | }
9 | fmt.Println(cumulativeSums[right] - cumulativeSums[left])
10 |
--------------------------------------------------------------------------------
/sprint1/By lessons/lesson6code2/lesson6code2.java:
--------------------------------------------------------------------------------
1 | int[] cumulativeSums = new int[sequence.length() + 1];
2 | int cgCount = 0;
3 |
4 | for (int i = 0; i < sequence.length(); i++) {
5 | if (sequence.charAt(i) == 'C' || sequence.charAt(i) == 'G') {
6 | cgCount++;
7 | }
8 | cumulativeSums[i + 1] = cgCount;
9 | }
10 |
11 | System.out.println(cumulativeSums[right] - cumulativeSums[left]);
12 |
--------------------------------------------------------------------------------
/sprint1/By lessons/lesson6code2/lesson6code2.js:
--------------------------------------------------------------------------------
1 | const cumulative_sums = [0];
2 | let cg_count = 0;
3 | for (let position = 0; position < sequence.length; position++) {
4 | if (sequence[position] === 'C' || sequence[position] === 'G') {
5 | cg_count++;
6 | }
7 | cumulative_sums.push(cg_count);
8 | }
9 | console.log(cumulative_sums[right] - cumulative_sums[left]);
10 |
--------------------------------------------------------------------------------
/sprint1/By lessons/lesson6code2/lesson6code2.kt:
--------------------------------------------------------------------------------
1 | Copy code
2 | var cumulativeSums = mutableListOf(0)
3 | var cgCount = 0
4 | for (position in 0 until sequence.length) {
5 | if (sequence[position] == 'C' || sequence[position] == 'G') {
6 | cgCount++
7 | }
8 | cumulativeSums.add(cgCount)
9 | }
10 |
11 | println(cumulativeSums[right] - cumulativeSums[left])
12 |
--------------------------------------------------------------------------------
/sprint1/By lessons/lesson6code2/lesson6code2.py:
--------------------------------------------------------------------------------
1 | cumulative_sums = [0]
2 | cg_count = 0
3 | for position in range(0, len(sequence)):
4 | if (sequence[position] == 'C') or (sequence[position] == 'G'):
5 | cg_count += 1
6 | cumulative_sums.append(cg_count)
7 |
8 | print(cumulative_sums[right] - cumulative_sums[left])
9 |
--------------------------------------------------------------------------------
/sprint1/By lessons/lesson7code1/lesson7code1.cpp:
--------------------------------------------------------------------------------
1 | #include
2 | using namespace std;
3 |
4 | bool is_prime(int n) {
5 | if (n == 1) {
6 | return false;
7 | }
8 | int i = 2;
9 | while (i < n) {
10 | if (n % i == 0) {
11 | return false;
12 | }
13 | i++;
14 | }
15 | return true;
16 | }
--------------------------------------------------------------------------------
/sprint1/By lessons/lesson7code1/lesson7code1.cs:
--------------------------------------------------------------------------------
1 | public static bool IsPrime(int n)
2 | {
3 | if (n == 1)
4 | {
5 | return false;
6 | }
7 |
8 | int i = 2;
9 |
10 | while (i < n)
11 | {
12 | if (n % i == 0)
13 | {
14 | return false;
15 | }
16 |
17 | i++;
18 | }
19 |
20 | return true;
21 | }
22 |
--------------------------------------------------------------------------------
/sprint1/By lessons/lesson7code1/lesson7code1.go:
--------------------------------------------------------------------------------
1 | func isPrime(n int) bool {
2 | if n < 2 {
3 | return false
4 | }
5 | for i := 2; i < n; i++ {
6 | if n%i == 0 {
7 | return false
8 | }
9 | }
10 | return true
11 | }
--------------------------------------------------------------------------------
/sprint1/By lessons/lesson7code1/lesson7code1.java:
--------------------------------------------------------------------------------
1 | public static boolean isPrime(int n) {
2 | if (n == 1) {
3 | return false;
4 | }
5 | int i = 2;
6 | while (i < n) {
7 | if (n % i == 0) {
8 | return false;
9 | }
10 | i = i + 1;
11 | }
12 | return true;
13 | }
14 |
--------------------------------------------------------------------------------
/sprint1/By lessons/lesson7code1/lesson7code1.js:
--------------------------------------------------------------------------------
1 | function is_prime(n) {
2 | if (n === 1) {
3 | return false;
4 | }
5 | let i = 2;
6 | while (i < n) {
7 | if (n % i === 0) {
8 | return false;
9 | }
10 | i++;
11 | }
12 | return true;
13 | }
14 |
--------------------------------------------------------------------------------
/sprint1/By lessons/lesson7code1/lesson7code1.kt:
--------------------------------------------------------------------------------
1 | fun isPrime(n: Int): Boolean {
2 | if (n == 1) return false
3 | var i = 2
4 | while (i < n) {
5 | if (n % i == 0) return false
6 | i++
7 | }
8 | return true
9 | }
10 |
--------------------------------------------------------------------------------
/sprint1/By lessons/lesson7code1/lesson7code1.py:
--------------------------------------------------------------------------------
1 | def is_prime(n):
2 | if n == 1:
3 | return False
4 | i = 2
5 | while i < n:
6 | if n % i == 0:
7 | return False
8 | i = i + 1
9 | return True
10 |
--------------------------------------------------------------------------------
/sprint1/By lessons/lesson7code1/lesson7code1.swift:
--------------------------------------------------------------------------------
1 | func isPrime(_ n: Int) -> Bool {
2 | if n == 1 {
3 | return false
4 | }
5 | var i = 2
6 | while i < n {
7 | if n % i == 0 {
8 | return false
9 | }
10 | i += 1
11 | }
12 | return true
13 | }
14 |
--------------------------------------------------------------------------------
/sprint1/By lessons/lesson7code2/lesson7code2.cpp:
--------------------------------------------------------------------------------
1 | #include
2 | using namespace std;
3 |
4 | bool is_prime(int n) {
5 | if (n == 1) {
6 | return false;
7 | }
8 | int i = 2;
9 | while (i * i <= n) {
10 | if (n % i == 0) {
11 | return false;
12 | }
13 | i++;
14 | }
15 | return true;
16 | }
--------------------------------------------------------------------------------
/sprint1/By lessons/lesson7code2/lesson7code2.cs:
--------------------------------------------------------------------------------
1 | public static bool IsPrime(int n)
2 | {
3 | if (n == 1)
4 | {
5 | return false;
6 | }
7 |
8 | int i = 2;
9 |
10 | while (i * i <= n)
11 | {
12 | if (n % i == 0)
13 | {
14 | return false;
15 | }
16 |
17 | i++;
18 | }
19 |
20 | return true;
21 | }
22 |
--------------------------------------------------------------------------------
/sprint1/By lessons/lesson7code2/lesson7code2.go:
--------------------------------------------------------------------------------
1 | func isPrime(n int) bool {
2 | if n < 2 {
3 | return false
4 | }
5 | for i := 2; i*i <= n; i++ {
6 | if n%i == 0 {
7 | return false
8 | }
9 | }
10 | return true
11 | }
--------------------------------------------------------------------------------
/sprint1/By lessons/lesson7code2/lesson7code2.java:
--------------------------------------------------------------------------------
1 | public static boolean isPrime(int n) {
2 | if (n == 1) {
3 | return false;
4 | }
5 | int i = 2;
6 | while (i * i <= n) {
7 | if (n % i == 0) {
8 | return false;
9 | }
10 | i = i + 1;
11 | }
12 | return true;
13 | }
14 |
--------------------------------------------------------------------------------
/sprint1/By lessons/lesson7code2/lesson7code2.js:
--------------------------------------------------------------------------------
1 | function is_prime(n) {
2 | if (n === 1) {
3 | return false;
4 | }
5 | let i = 2;
6 | while (i * i <= n) {
7 | if (n % i === 0) {
8 | return false;
9 | }
10 | i++;
11 | }
12 | return true;
13 | }
14 |
--------------------------------------------------------------------------------
/sprint1/By lessons/lesson7code2/lesson7code2.kt:
--------------------------------------------------------------------------------
1 | fun isPrime(n: Int): Boolean {
2 | if (n == 1) return false
3 | var i = 2
4 | while (i * i <= n) {
5 | if (n % i == 0) return false
6 | i++
7 | }
8 | return true
9 | }
10 |
--------------------------------------------------------------------------------
/sprint1/By lessons/lesson7code2/lesson7code2.py:
--------------------------------------------------------------------------------
1 | def is_prime(n):
2 | if n == 1:
3 | return False
4 | i = 2
5 | while i * i <= n:
6 | if n % i == 0:
7 | return False
8 | i = i + 1
9 | return True
10 |
--------------------------------------------------------------------------------
/sprint1/By lessons/lesson7code2/lesson7code2.swift:
--------------------------------------------------------------------------------
1 | func isPrime(_ n: Int) -> Bool {
2 | if n == 1 {
3 | return false
4 | }
5 | var i = 2
6 | while i * i <= n {
7 | if n % i == 0 {
8 | return false
9 | }
10 | i += 1
11 | }
12 | return true
13 | }
--------------------------------------------------------------------------------
/sprint1/By lessons/lesson7code3/lesson7code3.cpp:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 | using namespace std;
4 |
5 | vector get_smaller_primes(int n) {
6 | vector smaller_primes;
7 | for (int num = 2; num <= n; num++) {
8 | if (is_prime(num)) {
9 | smaller_primes.push_back(num);
10 | }
11 | }
12 | return smaller_primes;
13 | }
14 |
--------------------------------------------------------------------------------
/sprint1/By lessons/lesson7code3/lesson7code3.cs:
--------------------------------------------------------------------------------
1 | public static List GetSmallerPrimes(int n)
2 | {
3 | List smallerPrimes = new List();
4 |
5 | for (int num = 2; num <= n; num++)
6 | {
7 | if (IsPrime(num))
8 | {
9 | smallerPrimes.Add(num);
10 | }
11 | }
12 |
13 | return smallerPrimes;
14 | }
15 |
--------------------------------------------------------------------------------
/sprint1/By lessons/lesson7code3/lesson7code3.java:
--------------------------------------------------------------------------------
1 | public static List getSmallerPrimes(int n) {
2 | List smallerPrimes = new ArrayList<>();
3 | for (int num = 2; num <= n; num++) {
4 | if (isPrime(num)) {
5 | smallerPrimes.add(num);
6 | }
7 | }
8 | return smallerPrimes;
9 | }
10 |
--------------------------------------------------------------------------------
/sprint1/By lessons/lesson7code3/lesson7code3.js:
--------------------------------------------------------------------------------
1 | function get_smaller_primes(n) {
2 | const smaller_primes = [];
3 | for (let num = 2; num <= n; num++) {
4 | if (is_prime(num)) {
5 | smaller_primes.push(num);
6 | }
7 | }
8 | return smaller_primes;
9 | }
10 |
--------------------------------------------------------------------------------
/sprint1/By lessons/lesson7code3/lesson7code3.kt:
--------------------------------------------------------------------------------
1 | fun getSmallerPrimes(n: Int): List {
2 | val smallerPrimes = mutableListOf()
3 | for (num in 2..n) {
4 | if (isPrime(num)) {
5 | smallerPrimes.add(num)
6 | }
7 | }
8 | return smallerPrimes
9 | }
10 |
--------------------------------------------------------------------------------
/sprint1/By lessons/lesson7code3/lesson7code3.py:
--------------------------------------------------------------------------------
1 | def get_smaller_primes(n):
2 | smaller_primes = []
3 | for num in range(2, n + 1):
4 | if is_prime(num):
5 | smaller_primes.append(num)
6 | return smaller_primes
7 |
--------------------------------------------------------------------------------
/sprint1/By lessons/lesson7code3/lesson7code3.swift:
--------------------------------------------------------------------------------
1 | func getSmallerPrimes(_ n: Int) -> [Int] {
2 | var smallerPrimes = [Int]()
3 | for num in 2...n {
4 | if isPrime(num) {
5 | smallerPrimes.append(num)
6 | }
7 | }
8 | return smallerPrimes
9 | }
--------------------------------------------------------------------------------
/sprint1/By lessons/lesson7code4/lesson7code4.js:
--------------------------------------------------------------------------------
1 | function eratosthenes(n) {
2 | const numbers = new Array(n + 1).fill(true);
3 | numbers[0] = numbers[1] = false;
4 | for (let num = 2; num < n; num++) {
5 | if (numbers[num]) {
6 | for (let j = 2 * num; j <= n; j += num) {
7 | numbers[j] = false;
8 | }
9 | }
10 | }
11 | return numbers;
12 | }
13 |
--------------------------------------------------------------------------------
/sprint1/By lessons/lesson7code4/lesson7code4.kt:
--------------------------------------------------------------------------------
1 | fun eratosthenes(n: Int): BooleanArray {
2 | val numbers = BooleanArray(n + 1) { true }
3 | numbers[0] = false
4 | numbers[1] = false
5 | for (num in 2..n) {
6 | if (numbers[num]) {
7 | for (j in (2 * num)..n step num) {
8 | numbers[j] = false
9 | }
10 | }
11 | }
12 | return numbers
13 | }
14 |
--------------------------------------------------------------------------------
/sprint1/By lessons/lesson7code4/lesson7code4.py:
--------------------------------------------------------------------------------
1 | def eratosthenes(n):
2 | numbers = list(range(n + 1))
3 | numbers[0] = numbers[1] = False
4 | for num in range(2, n):
5 | if numbers[num]:
6 | for j in range(2 * num, n + 1, num):
7 | numbers[j] = False
8 | return numbers
9 |
--------------------------------------------------------------------------------
/sprint1/By lessons/lesson7code5/lesson7code5.js:
--------------------------------------------------------------------------------
1 | function eratosthenes_effective(n) {
2 | const numbers = new Array(n + 1).fill(true);
3 | numbers[0] = numbers[1] = false;
4 | for (let num = 2; num < n; num++) {
5 | if (numbers[num]) {
6 | for (let j = num * num; j <= n; j += num) {
7 | numbers[j] = false;
8 | }
9 | }
10 | }
11 | return numbers;
12 | }
13 |
--------------------------------------------------------------------------------
/sprint1/By lessons/lesson7code5/lesson7code5.kt:
--------------------------------------------------------------------------------
1 | fun eratosthenesEffective(n: Int): BooleanArray {
2 | val numbers = BooleanArray(n + 1) { true }
3 | numbers[0] = false
4 | numbers[1] = false
5 | for (num in 2..n) {
6 | if (numbers[num]) {
7 | for (j in (num * num)..n step num) {
8 | numbers[j] = false
9 | }
10 | }
11 | }
12 | return numbers
13 | }
14 |
--------------------------------------------------------------------------------
/sprint1/By lessons/lesson7code5/lesson7code5.py:
--------------------------------------------------------------------------------
1 | def eratosthenes_effective(n):
2 | numbers = list(range(n + 1))
3 | numbers[0] = numbers[1] = False
4 | for num in range(2, n):
5 | if numbers[num]:
6 | for j in range(num * num, n + 1, num):
7 | numbers[j] = False
8 | return numbers
9 |
--------------------------------------------------------------------------------
/sprint1/By lessons/lesson7code6/lesson7code6.py:
--------------------------------------------------------------------------------
1 | def get_least_primes_linear(n):
2 | lp = [0] * (n + 1)
3 | primes = []
4 | for i in range(2, n + 1):
5 | if lp[i] == 0:
6 | lp[i] = i
7 | primes.append(i)
8 | for p in primes:
9 | x = p * i
10 | if (p > lp[i]) or (x > n):
11 | break
12 | lp[x] = p
13 | return primes, lp
14 |
--------------------------------------------------------------------------------
/sprint2/By languages/C#/lesson11code1.cs:
--------------------------------------------------------------------------------
1 | int factorial(int n)
2 | {
3 | if (n == 1 || n == 0)
4 | return 1;
5 | return n * factorial(n - 1);
6 | }
7 |
--------------------------------------------------------------------------------
/sprint2/By languages/C#/lesson11code2.cs:
--------------------------------------------------------------------------------
1 | int factorial(int n)
2 | {
3 | int accumulator = 1;
4 | int i = n;
5 | while (i > 1)
6 | {
7 | accumulator *= i;
8 | i -= 1;
9 | }
10 | return accumulator;
11 | }
--------------------------------------------------------------------------------
/sprint2/By languages/C++/lesson11code1.cpp:
--------------------------------------------------------------------------------
1 | #include
2 |
3 | int factorial(int n) {
4 | if (n == 1 || n == 0) {
5 | return 1;
6 | }
7 | return n * factorial(n - 1);
8 | }
9 |
10 | int main() {
11 | std::cout << factorial(5) << std::endl; // 120
12 | return 0;
13 | }
14 |
--------------------------------------------------------------------------------
/sprint2/By languages/C++/lesson11code2.cpp:
--------------------------------------------------------------------------------
1 | #include
2 |
3 | int factorial(int n) {
4 | int accumulator = 1;
5 | int i = n;
6 | while (i > 1) {
7 | accumulator *= i;
8 | i -= 1;
9 | }
10 | return accumulator;
11 | }
12 |
13 |
14 | int main() {
15 | std::cout << factorial(5) << std::endl; // 120
16 | return 0;
17 | }
18 |
--------------------------------------------------------------------------------
/sprint2/By languages/JS/lesson11code1.js:
--------------------------------------------------------------------------------
1 | function factorial(n) {
2 | if (n == 1 || n == 0) {
3 | return 1;
4 | }
5 | return n * factorial(n - 1);
6 | }
7 |
--------------------------------------------------------------------------------
/sprint2/By languages/JS/lesson11code2.js:
--------------------------------------------------------------------------------
1 | function factorial(n) {
2 | let accumulator = 1;
3 | let i = n;
4 | while (i > 1) {
5 | accumulator *= i;
6 | i -= 1;
7 | }
8 | return accumulator;
9 | }
10 |
--------------------------------------------------------------------------------
/sprint2/By languages/JS/lesson3code1.js:
--------------------------------------------------------------------------------
1 | let films_wish_list = ["Джон Уик 3", "Аватар 2", "Форсаж 9", "Индиана Джонс 5", "Бэтмен"];
2 | films_wish_list.push('Чёрная Вдова');
3 |
4 | let list_of_tasks = ["Полить цветы", "Приготовить завтрак", "Пойти на работу", "Сходить в магазин", "Позвонить бабушке"];
5 |
--------------------------------------------------------------------------------
/sprint2/By languages/Java/lesson11code1.java:
--------------------------------------------------------------------------------
1 | public class Main {
2 | public static int factorial(int n) {
3 | if (n == 1 || n == 0) {
4 | return 1;
5 | }
6 | return n * factorial(n - 1);
7 | }
8 |
9 | public static void main(String[] args) {
10 | System.out.println(factorial(5)); // Output: 120
11 | }
12 | }
13 |
--------------------------------------------------------------------------------
/sprint2/By languages/go/lesson11code1.go:
--------------------------------------------------------------------------------
1 | package main
2 |
3 | import "fmt"
4 |
5 | func factorial(n int) int {
6 | if n == 1 || n == 0 {
7 | return 1
8 | }
9 | return n * factorial(n-1)
10 | }
11 |
12 | func main() {
13 | fmt.Println(factorial(5)) // 120
14 | }
15 |
--------------------------------------------------------------------------------
/sprint2/By languages/go/lesson11code2.go:
--------------------------------------------------------------------------------
1 | package main
2 |
3 | import "fmt"
4 |
5 | func factorial(n int) int {
6 | accumulator := 1
7 | i := n
8 | for i > 1 {
9 | accumulator *= i
10 | i -= 1
11 | }
12 | return accumulator
13 | }
14 |
15 | func main() {
16 | fmt.Println(factorial(5)) // 120
17 | }
18 |
--------------------------------------------------------------------------------
/sprint2/By languages/kotlin/lesson11code1.kt:
--------------------------------------------------------------------------------
1 | fun factorial(n: Int): Int {
2 | return when (n) {
3 | 0, 1 -> 1
4 | else -> n * factorial(n - 1)
5 | }
6 | }
7 |
--------------------------------------------------------------------------------
/sprint2/By languages/kotlin/lesson11code2.kt:
--------------------------------------------------------------------------------
1 | fun factorial(n: Int): Int {
2 | var accumulator = 1
3 | var i = n
4 | while (i > 1) {
5 | accumulator *= i
6 | i--
7 | }
8 | return accumulator
9 | }
10 |
--------------------------------------------------------------------------------
/sprint2/By languages/kotlin/lesson3code1.kt:
--------------------------------------------------------------------------------
1 | var filmsWishList = mutableListOf("Джон Уик 3", "Аватар 2", "Форсаж 9", "Индиана Джонс 5", "Бэтмен")
2 | filmsWishList.add("Чёрная Вдова")
--------------------------------------------------------------------------------
/sprint2/By languages/python/lesson10code1.py:
--------------------------------------------------------------------------------
1 | def func(step):
2 | print('Call me. Step:', step)
3 |
4 | func(1)
5 | func(2)
6 | func(3)
7 |
8 | def say_hello(name):
9 | print(f"Привет, {name}")
10 | print_horoscope(name.upper())
11 | print(f"Пока, {name}, хорошего дня!")
12 |
13 | def print_horoscope(name):
14 | print(f"{name}! Сегодня подходящий день для прогулок в парке и изучения рекурсии")
15 |
16 | say_hello('Гоша')
--------------------------------------------------------------------------------
/sprint2/By languages/python/lesson11code1.py:
--------------------------------------------------------------------------------
1 | def factorial(n):
2 | if n == 1 or n == 0:
3 | return 1
4 | return n * factorial(n - 1)
5 |
--------------------------------------------------------------------------------
/sprint2/By languages/python/lesson11code2.py:
--------------------------------------------------------------------------------
1 | def factorial(n):
2 | accumulator = 1
3 | i = n
4 | while i > 1:
5 | accumulator *= i
6 | i -= 1
7 | return accumulator
8 |
--------------------------------------------------------------------------------
/sprint2/By languages/python/lesson3code1.py:
--------------------------------------------------------------------------------
1 | from typing import List
2 |
3 | films_wish_list: List[str] = ["Джон Уик 3", "Аватар 2", "Форсаж 9", "Индиана Джонс 5", "Бэтмен"]
4 | films_wish_list.append('Чёрная Вдова')
5 |
6 | list_of_tasks: List[str] = ["Полить цветы", "Приготовить завтрак", "Пойти на работу", "Сходить в магазин", "Позвонить бабушке"]
7 |
--------------------------------------------------------------------------------
/sprint2/By languages/swift/lesson11code1.swift:
--------------------------------------------------------------------------------
1 | func factorial(_ n: Int) -> Int {
2 | if n == 1 || n == 0 {
3 | return 1
4 | }
5 | return n * factorial(n - 1)
6 | }
7 |
--------------------------------------------------------------------------------
/sprint2/By languages/swift/lesson11code2.swift:
--------------------------------------------------------------------------------
1 | func factorial(_ n: Int) -> Int {
2 | var accumulator = 1
3 | var i = n
4 | while i > 1 {
5 | accumulator *= i
6 | i -= 1
7 | }
8 | return accumulator
9 | }
--------------------------------------------------------------------------------
/sprint2/By languages/swift/lesson3code1.swift:
--------------------------------------------------------------------------------
1 | var filmsWishList: [String] = ["Джон Уик 3", "Аватар 2", "Форсаж 9", "Индиана Джонс 5", "Бэтмен"]
2 | filmsWishList.append("Чёрная Вдова")
3 |
4 | var listOfTasks: [String] = ["Полить цветы", "Приготовить завтрак", "Пойти на работу", "Сходить в магазин", "Позвонить бабушке"]
5 |
--------------------------------------------------------------------------------
/sprint2/By lessons/lesson10code1/lesson10code1.py:
--------------------------------------------------------------------------------
1 | def func(step):
2 | print('Call me. Step:', step)
3 |
4 | func(1)
5 | func(2)
6 | func(3)
7 |
8 | def say_hello(name):
9 | print(f"Привет, {name}")
10 | print_horoscope(name.upper())
11 | print(f"Пока, {name}, хорошего дня!")
12 |
13 | def print_horoscope(name):
14 | print(f"{name}! Сегодня подходящий день для прогулок в парке и изучения рекурсии")
15 |
16 | say_hello('Гоша')
--------------------------------------------------------------------------------
/sprint2/By lessons/lesson11code1/lesson11code1.cpp:
--------------------------------------------------------------------------------
1 | #include
2 |
3 | int factorial(int n) {
4 | if (n == 1 || n == 0) {
5 | return 1;
6 | }
7 | return n * factorial(n - 1);
8 | }
9 |
10 | int main() {
11 | std::cout << factorial(5) << std::endl; // 120
12 | return 0;
13 | }
14 |
--------------------------------------------------------------------------------
/sprint2/By lessons/lesson11code1/lesson11code1.cs:
--------------------------------------------------------------------------------
1 | int factorial(int n)
2 | {
3 | if (n == 1 || n == 0)
4 | return 1;
5 | return n * factorial(n - 1);
6 | }
7 |
--------------------------------------------------------------------------------
/sprint2/By lessons/lesson11code1/lesson11code1.go:
--------------------------------------------------------------------------------
1 | package main
2 |
3 | import "fmt"
4 |
5 | func factorial(n int) int {
6 | if n == 1 || n == 0 {
7 | return 1
8 | }
9 | return n * factorial(n-1)
10 | }
11 |
12 | func main() {
13 | fmt.Println(factorial(5)) // 120
14 | }
15 |
--------------------------------------------------------------------------------
/sprint2/By lessons/lesson11code1/lesson11code1.java:
--------------------------------------------------------------------------------
1 | public class Main {
2 | public static int factorial(int n) {
3 | if (n == 1 || n == 0) {
4 | return 1;
5 | }
6 | return n * factorial(n - 1);
7 | }
8 |
9 | public static void main(String[] args) {
10 | System.out.println(factorial(5)); // Output: 120
11 | }
12 | }
13 |
--------------------------------------------------------------------------------
/sprint2/By lessons/lesson11code1/lesson11code1.js:
--------------------------------------------------------------------------------
1 | function factorial(n) {
2 | if (n == 1 || n == 0) {
3 | return 1;
4 | }
5 | return n * factorial(n - 1);
6 | }
7 |
--------------------------------------------------------------------------------
/sprint2/By lessons/lesson11code1/lesson11code1.kt:
--------------------------------------------------------------------------------
1 | fun factorial(n: Int): Int {
2 | return when (n) {
3 | 0, 1 -> 1
4 | else -> n * factorial(n - 1)
5 | }
6 | }
7 |
--------------------------------------------------------------------------------
/sprint2/By lessons/lesson11code1/lesson11code1.py:
--------------------------------------------------------------------------------
1 | def factorial(n):
2 | if n == 1 or n == 0:
3 | return 1
4 | return n * factorial(n - 1)
5 |
--------------------------------------------------------------------------------
/sprint2/By lessons/lesson11code1/lesson11code1.swift:
--------------------------------------------------------------------------------
1 | func factorial(_ n: Int) -> Int {
2 | if n == 1 || n == 0 {
3 | return 1
4 | }
5 | return n * factorial(n - 1)
6 | }
7 |
--------------------------------------------------------------------------------
/sprint2/By lessons/lesson11code2/lesson11code2.cpp:
--------------------------------------------------------------------------------
1 | #include
2 |
3 | int factorial(int n) {
4 | int accumulator = 1;
5 | int i = n;
6 | while (i > 1) {
7 | accumulator *= i;
8 | i -= 1;
9 | }
10 | return accumulator;
11 | }
12 |
13 |
14 | int main() {
15 | std::cout << factorial(5) << std::endl; // 120
16 | return 0;
17 | }
18 |
--------------------------------------------------------------------------------
/sprint2/By lessons/lesson11code2/lesson11code2.cs:
--------------------------------------------------------------------------------
1 | int factorial(int n)
2 | {
3 | int accumulator = 1;
4 | int i = n;
5 | while (i > 1)
6 | {
7 | accumulator *= i;
8 | i -= 1;
9 | }
10 | return accumulator;
11 | }
--------------------------------------------------------------------------------
/sprint2/By lessons/lesson11code2/lesson11code2.go:
--------------------------------------------------------------------------------
1 | package main
2 |
3 | import "fmt"
4 |
5 | func factorial(n int) int {
6 | accumulator := 1
7 | i := n
8 | for i > 1 {
9 | accumulator *= i
10 | i -= 1
11 | }
12 | return accumulator
13 | }
14 |
15 | func main() {
16 | fmt.Println(factorial(5)) // 120
17 | }
18 |
--------------------------------------------------------------------------------
/sprint2/By lessons/lesson11code2/lesson11code2.js:
--------------------------------------------------------------------------------
1 | function factorial(n) {
2 | let accumulator = 1;
3 | let i = n;
4 | while (i > 1) {
5 | accumulator *= i;
6 | i -= 1;
7 | }
8 | return accumulator;
9 | }
10 |
--------------------------------------------------------------------------------
/sprint2/By lessons/lesson11code2/lesson11code2.kt:
--------------------------------------------------------------------------------
1 | fun factorial(n: Int): Int {
2 | var accumulator = 1
3 | var i = n
4 | while (i > 1) {
5 | accumulator *= i
6 | i--
7 | }
8 | return accumulator
9 | }
10 |
--------------------------------------------------------------------------------
/sprint2/By lessons/lesson11code2/lesson11code2.py:
--------------------------------------------------------------------------------
1 | def factorial(n):
2 | accumulator = 1
3 | i = n
4 | while i > 1:
5 | accumulator *= i
6 | i -= 1
7 | return accumulator
8 |
--------------------------------------------------------------------------------
/sprint2/By lessons/lesson11code2/lesson11code2.swift:
--------------------------------------------------------------------------------
1 | func factorial(_ n: Int) -> Int {
2 | var accumulator = 1
3 | var i = n
4 | while i > 1 {
5 | accumulator *= i
6 | i -= 1
7 | }
8 | return accumulator
9 | }
--------------------------------------------------------------------------------
/sprint2/By lessons/lesson3code1/lesson3code1.js:
--------------------------------------------------------------------------------
1 | let films_wish_list = ["Джон Уик 3", "Аватар 2", "Форсаж 9", "Индиана Джонс 5", "Бэтмен"];
2 | films_wish_list.push('Чёрная Вдова');
3 |
4 | let list_of_tasks = ["Полить цветы", "Приготовить завтрак", "Пойти на работу", "Сходить в магазин", "Позвонить бабушке"];
5 |
--------------------------------------------------------------------------------
/sprint2/By lessons/lesson3code1/lesson3code1.kt:
--------------------------------------------------------------------------------
1 | var filmsWishList = mutableListOf("Джон Уик 3", "Аватар 2", "Форсаж 9", "Индиана Джонс 5", "Бэтмен")
2 | filmsWishList.add("Чёрная Вдова")
--------------------------------------------------------------------------------
/sprint2/By lessons/lesson3code1/lesson3code1.py:
--------------------------------------------------------------------------------
1 | from typing import List
2 |
3 | films_wish_list: List[str] = ["Джон Уик 3", "Аватар 2", "Форсаж 9", "Индиана Джонс 5", "Бэтмен"]
4 | films_wish_list.append('Чёрная Вдова')
5 |
6 | list_of_tasks: List[str] = ["Полить цветы", "Приготовить завтрак", "Пойти на работу", "Сходить в магазин", "Позвонить бабушке"]
7 |
--------------------------------------------------------------------------------
/sprint2/By lessons/lesson3code1/lesson3code1.swift:
--------------------------------------------------------------------------------
1 | var filmsWishList: [String] = ["Джон Уик 3", "Аватар 2", "Форсаж 9", "Индиана Джонс 5", "Бэтмен"]
2 | filmsWishList.append("Чёрная Вдова")
3 |
4 | var listOfTasks: [String] = ["Полить цветы", "Приготовить завтрак", "Пойти на работу", "Сходить в магазин", "Позвонить бабушке"]
5 |
--------------------------------------------------------------------------------
/sprint3/By languages/C#/lesson2code1.cs:
--------------------------------------------------------------------------------
1 | using System;
2 |
3 | class Program {
4 | static void stairs_builder(int n) {
5 | // build 1 step
6 | Console.WriteLine($"Осталось построить {n} ступеней.");
7 | stairs_builder(n - 1);
8 | }
9 |
10 | static void Main(string[] args) {
11 | stairs_builder(5);
12 | }
13 | }
14 |
--------------------------------------------------------------------------------
/sprint3/By languages/C#/lesson2code2.cs:
--------------------------------------------------------------------------------
1 | using System;
2 |
3 | class Program {
4 | static void stairs_builder(int n) {
5 | if (n == 0) {
6 | return;
7 | }
8 | // build 1 step
9 | Console.WriteLine($"Осталось построить {n} ступеней.");
10 | stairs_builder(n - 1);
11 | }
12 |
13 | static void Main(string[] args) {
14 | stairs_builder(5);
15 | }
16 | }
17 |
--------------------------------------------------------------------------------
/sprint3/By languages/C#/lesson2code3.cs:
--------------------------------------------------------------------------------
1 | public static string AsBinaryString(int n)
2 | {
3 | if (n < 0)
4 | return "-" + AsBinaryString(-n);
5 | int lastDigit = n % 2;
6 | return AsBinaryString(n / 2) + lastDigit.ToString();
7 | }
8 |
--------------------------------------------------------------------------------
/sprint3/By languages/C#/lesson2code4.cs:
--------------------------------------------------------------------------------
1 | public static string AsBinaryString(int n)
2 | {
3 | if (n < 0)
4 | return "-" + AsBinaryString(-n);
5 | if (n == 0 || n == 1)
6 | return n.ToString();
7 | int lastDigit = n % 2;
8 | return AsBinaryString(n / 2) + lastDigit.ToString();
9 | }
10 |
--------------------------------------------------------------------------------
/sprint3/By languages/C#/lesson4code1.cs:
--------------------------------------------------------------------------------
1 | using System;
2 |
3 | public class Program {
4 | static void Main(string[] args) {
5 | GenBinary(3, "");
6 | }
7 |
8 | static void GenBinary(int n, string prefix) {
9 | if (n == 0) {
10 | Console.WriteLine(prefix);
11 | } else {
12 | GenBinary(n - 1, prefix + "0");
13 | GenBinary(n - 1, prefix + "1");
14 | }
15 | }
16 | }
17 |
--------------------------------------------------------------------------------
/sprint3/By languages/C++/lesson2code1.cpp:
--------------------------------------------------------------------------------
1 | #include
2 |
3 | void stairs_builder(int n) {
4 | // build 1 step
5 | std::cout << "Осталось построить " << n << " ступеней." << std::endl;
6 | stairs_builder(n - 1);
7 | }
8 |
9 | int main() {
10 | stairs_builder(5);
11 | return 0;
12 | }
13 |
--------------------------------------------------------------------------------
/sprint3/By languages/C++/lesson2code2.cpp:
--------------------------------------------------------------------------------
1 | #include
2 |
3 | void stairs_builder(int n) {
4 | if (n == 0) {
5 | return;
6 | }
7 | // build 1 step
8 | std::cout << "Осталось построить " << n << " ступеней." << std::endl;
9 | stairs_builder(n - 1);
10 | }
11 |
12 | int main() {
13 | stairs_builder(5);
14 | return 0;
15 | }
16 |
--------------------------------------------------------------------------------
/sprint3/By languages/C++/lesson2code3.cpp:
--------------------------------------------------------------------------------
1 | #include
2 |
3 | std::string as_binary_string(int n) {
4 | if (n < 0) {
5 | return "-" + as_binary_string(-n);
6 | }
7 | int last_digit = n % 2;
8 | return as_binary_string(n / 2) + std::to_string(last_digit);
9 | }
10 |
--------------------------------------------------------------------------------
/sprint3/By languages/C++/lesson2code4.cpp:
--------------------------------------------------------------------------------
1 | #include
2 |
3 | std::string as_binary_string(int n) {
4 | if (n < 0) {
5 | return "-" + as_binary_string(-n);
6 | }
7 | if (n == 0 || n == 1) {
8 | return std::to_string(n);
9 | }
10 | int last_digit = n % 2;
11 | return as_binary_string(n / 2) + std::to_string(last_digit);
12 | }
13 |
--------------------------------------------------------------------------------
/sprint3/By languages/C++/lesson4code1.cpp:
--------------------------------------------------------------------------------
1 | #include
2 | using namespace std;
3 |
4 | void gen_binary(int n, string prefix) {
5 | if (n == 0) {
6 | cout << prefix << endl;
7 | } else {
8 | gen_binary(n - 1, prefix + "0");
9 | gen_binary(n - 1, prefix + "1");
10 | }
11 | }
12 |
13 | int main() {
14 | gen_binary(3, "");
15 | return 0;
16 | }
17 |
--------------------------------------------------------------------------------
/sprint3/By languages/JS/lesson14code1.js:
--------------------------------------------------------------------------------
1 | function countingSort(array, k) {
2 | const countedValues = new Array(k).fill(0);
3 | for (const value of array) {
4 | countedValues[value]++;
5 | }
6 |
7 | let index = 0;
8 | for (let value = 0; value < k; value++) {
9 | for (let amount = 0; amount < countedValues[value]; amount++) {
10 | array[index] = value;
11 | index++;
12 | }
13 | }
14 | return array;
15 | }
16 |
--------------------------------------------------------------------------------
/sprint3/By languages/JS/lesson2code1.js:
--------------------------------------------------------------------------------
1 | function stairs_builder(n) {
2 | // build 1 step
3 | console.log(`Осталось построить ${n} ступеней.`);
4 | stairs_builder(n - 1);
5 | }
6 |
7 | stairs_builder(5);
8 |
--------------------------------------------------------------------------------
/sprint3/By languages/JS/lesson2code2.js:
--------------------------------------------------------------------------------
1 | function stairs_builder(n) {
2 | if (n === 0) {
3 | return;
4 | }
5 | // build 1 step
6 | console.log(`Осталось построить ${n} ступеней.`);
7 | stairs_builder(n - 1);
8 | }
9 |
10 | stairs_builder(5);
11 |
--------------------------------------------------------------------------------
/sprint3/By languages/JS/lesson2code3.js:
--------------------------------------------------------------------------------
1 | function as_binary_string(n) {
2 | if (n < 0) {
3 | return "-" + as_binary_string(-n);
4 | }
5 | let last_digit = n % 2;
6 | return as_binary_string(Math.floor(n / 2)) + last_digit.toString();
7 | }
8 |
--------------------------------------------------------------------------------
/sprint3/By languages/JS/lesson2code4.js:
--------------------------------------------------------------------------------
1 | function as_binary_string(n) {
2 | if (n < 0) {
3 | return "-" + as_binary_string(-n);
4 | }
5 | if (n == 0 || n == 1) {
6 | return n.toString();
7 | }
8 | let last_digit = n % 2;
9 | return as_binary_string(Math.floor(n / 2)) + last_digit.toString();
10 | }
11 |
--------------------------------------------------------------------------------
/sprint3/By languages/JS/lesson4code1.js:
--------------------------------------------------------------------------------
1 | function genBinary(n, prefix) {
2 | if (n == 0) {
3 | console.log(prefix);
4 | } else {
5 | genBinary(n - 1, prefix + "0");
6 | genBinary(n - 1, prefix + "1");
7 | }
8 | }
9 |
10 | genBinary(3, "");
11 |
--------------------------------------------------------------------------------
/sprint3/By languages/JS/lesson9code1.js:
--------------------------------------------------------------------------------
1 | let digit_lengths = [4, 4, 3, 3, 6, 4, 5, 4, 6, 6]; // длины слов «ноль», «один»,...
2 |
3 | function key_for_card(card) {
4 | return [-digit_lengths[card], card];
5 | }
6 |
7 | let cards = [2, 3, 7];
8 | cards.sort((a, b) => key_for_card(a) < key_for_card(b) ? -1 : 1);
9 | console.log(cards);
10 |
--------------------------------------------------------------------------------
/sprint3/By languages/Java/lesson2code1.java:
--------------------------------------------------------------------------------
1 | class Main {
2 | static void stairs_builder(int n) {
3 | // build 1 step
4 | System.out.printf("Осталось построить %d ступеней.\n", n);
5 | stairs_builder(n - 1);
6 | }
7 |
8 | public static void main(String[] args) {
9 | stairs_builder(5);
10 | }
11 | }
12 |
--------------------------------------------------------------------------------
/sprint3/By languages/Java/lesson2code2.java:
--------------------------------------------------------------------------------
1 | class Main {
2 | static void stairs_builder(int n) {
3 | if (n == 0) {
4 | return;
5 | }
6 | // build 1 step
7 | System.out.printf("Осталось построить %d ступеней.\n", n);
8 | stairs_builder(n - 1);
9 | }
10 |
11 | public static void main(String[] args) {
12 | stairs_builder(5);
13 | }
14 | }
15 |
--------------------------------------------------------------------------------
/sprint3/By languages/Java/lesson2code3.java:
--------------------------------------------------------------------------------
1 | public static String asBinaryString(int n) {
2 | if (n < 0) {
3 | return "-" + asBinaryString(-n);
4 | }
5 | int lastDigit = n % 2;
6 | return asBinaryString(n / 2) + Integer.toString(lastDigit);
7 | }
8 |
--------------------------------------------------------------------------------
/sprint3/By languages/Java/lesson2code4.java:
--------------------------------------------------------------------------------
1 | public static String asBinaryString(int n) {
2 | if (n < 0) {
3 | return "-" + asBinaryString(-n);
4 | }
5 | if (n == 0 || n == 1) {
6 | return Integer.toString(n);
7 | }
8 | int lastDigit = n % 2;
9 | return asBinaryString(n / 2) + Integer.toString(lastDigit);
10 | }
11 |
--------------------------------------------------------------------------------
/sprint3/By languages/Java/lesson4code1.java:
--------------------------------------------------------------------------------
1 | public class Main {
2 | public static void main(String[] args) {
3 | genBinary(3, "");
4 | }
5 |
6 | static void genBinary(int n, String prefix) {
7 | if (n == 0) {
8 | System.out.println(prefix);
9 | } else {
10 | genBinary(n - 1, prefix + "0");
11 | genBinary(n - 1, prefix + "1");
12 | }
13 | }
14 | }
15 |
--------------------------------------------------------------------------------
/sprint3/By languages/go/lesson14code1.go:
--------------------------------------------------------------------------------
1 | func countingSort(array []int, k int) []int {
2 | countedValues := make([]int, k)
3 | for _, value := range array {
4 | countedValues[value]++
5 | }
6 |
7 | index := 0
8 | for value := 0; value < k; value++ {
9 | for amount := 0; amount < countedValues[value]; amount++ {
10 | array[index] = value
11 | index++
12 | }
13 | }
14 | return array
15 | }
16 |
--------------------------------------------------------------------------------
/sprint3/By languages/go/lesson2code1.go:
--------------------------------------------------------------------------------
1 | package main
2 |
3 | import "fmt"
4 |
5 | func stairsBuilder(n int) {
6 | // build 1 step
7 | fmt.Printf("Осталось построить %d ступеней.\n", n)
8 | stairsBuilder(n - 1)
9 | }
10 |
11 | func main() {
12 | stairsBuilder(5)
13 | }
14 |
--------------------------------------------------------------------------------
/sprint3/By languages/go/lesson2code2.go:
--------------------------------------------------------------------------------
1 | package main
2 |
3 | import "fmt"
4 |
5 | func stairsBuilder(n int) {
6 | if n == 0 {
7 | return
8 | }
9 | // build 1 step
10 | fmt.Printf("Осталось построить %d ступеней.\n", n)
11 | stairsBuilder(n - 1)
12 | }
13 |
14 | func main() {
15 | stairsBuilder(5)
16 | }
17 |
--------------------------------------------------------------------------------
/sprint3/By languages/go/lesson2code3.go:
--------------------------------------------------------------------------------
1 | func asBinaryString(n int) string {
2 | if n < 0 {
3 | return "-" + asBinaryString(-n)
4 | }
5 | lastDigit := n % 2
6 | return asBinaryString(n / 2) + strconv.Itoa(lastDigit)
7 | }
8 |
--------------------------------------------------------------------------------
/sprint3/By languages/go/lesson2code4.go:
--------------------------------------------------------------------------------
1 | func asBinaryString(n int) string {
2 | if n < 0 {
3 | return "-" + asBinaryString(-n)
4 | }
5 | if n == 0 || n == 1 {
6 | return strconv.Itoa(n)
7 | }
8 | lastDigit := n % 2
9 | return asBinaryString(n / 2) + strconv.Itoa(lastDigit)
10 | }
11 |
--------------------------------------------------------------------------------
/sprint3/By languages/go/lesson4code1.go:
--------------------------------------------------------------------------------
1 | package main
2 |
3 | import "fmt"
4 |
5 | func main() {
6 | genBinary(3, "")
7 | }
8 |
9 | func genBinary(n int, prefix string) {
10 | if n == 0 {
11 | fmt.Println(prefix)
12 | } else {
13 | genBinary(n-1, prefix+"0")
14 | genBinary(n-1, prefix+"1")
15 | }
16 | }
17 |
--------------------------------------------------------------------------------
/sprint3/By languages/kotlin/lesson14code1.kt:
--------------------------------------------------------------------------------
1 | fun countingSort(array: IntArray, k: Int): IntArray {
2 | val countedValues = IntArray(k) { 0 }
3 | for (value in array) {
4 | countedValues[value]++
5 | }
6 |
7 | var index = 0
8 | for (value in 0 until k) {
9 | for (amount in 1..countedValues[value]) {
10 | array[index] = value
11 | index++
12 | }
13 | }
14 | return array
15 | }
16 |
--------------------------------------------------------------------------------
/sprint3/By languages/kotlin/lesson2code1.kt:
--------------------------------------------------------------------------------
1 | fun stairs_builder(n: Int) {
2 | // build 1 step
3 | println("Осталось построить $n ступеней.")
4 | stairs_builder(n - 1)
5 | }
6 |
--------------------------------------------------------------------------------
/sprint3/By languages/kotlin/lesson2code2.kt:
--------------------------------------------------------------------------------
1 | fun stairs_builder(n: Int) {
2 | if (n == 0) return
3 | // build 1 step
4 | println("Осталось построить $n ступеней.")
5 | stairs_builder(n - 1)
6 | }
7 |
--------------------------------------------------------------------------------
/sprint3/By languages/kotlin/lesson2code3.kt:
--------------------------------------------------------------------------------
1 | fun as_binary_string(n: Int): String {
2 | if (n < 0) return "-" + as_binary_string(-n)
3 | val lastDigit = n % 2
4 | return as_binary_string(n / 2) + lastDigit.toString()
5 | }
--------------------------------------------------------------------------------
/sprint3/By languages/kotlin/lesson2code4.kt:
--------------------------------------------------------------------------------
1 | fun as_binary_string(n: Int): String {
2 | if (n < 0) return "-" + as_binary_string(-n)
3 | if (n == 0 || n == 1) return n.toString()
4 | val lastDigit = n % 2
5 | return as_binary_string(n / 2) + lastDigit.toString()
6 | }
--------------------------------------------------------------------------------
/sprint3/By languages/kotlin/lesson4code1.kt:
--------------------------------------------------------------------------------
1 | fun genBinary(n: Int, prefix: String) {
2 | if (n == 0) {
3 | println(prefix)
4 | } else {
5 | genBinary(n - 1, prefix + "0")
6 | genBinary(n - 1, prefix + "1")
7 | }
8 | }
9 |
--------------------------------------------------------------------------------
/sprint3/By languages/kotlin/lesson9code1.kt:
--------------------------------------------------------------------------------
1 | val digitLengths = intArrayOf(4, 4, 3, 3, 6, 4, 5, 4, 6, 6) // длины слов «ноль», «один»,...
2 |
3 | fun keyForCard(card: Int): List {
4 | return listOf(-digitLengths[card], card)
5 | }
6 |
7 | val cards = intArrayOf(2, 3 ,7)
8 | cards.sortBy { keyForCard(it) }
9 | println(cards.toList())
10 |
--------------------------------------------------------------------------------
/sprint3/By languages/python/lesson14code1.py:
--------------------------------------------------------------------------------
1 | def counting_sort(array, k):
2 | counted_values = [0] * k
3 | for value in array:
4 | counted_values[value] += 1
5 |
6 | index = 0
7 | for value in range(k):
8 | for amount in range(counted_values[value]):
9 | array[index] = value
10 | index += 1
11 | return array
12 |
--------------------------------------------------------------------------------
/sprint3/By languages/python/lesson2code1.py:
--------------------------------------------------------------------------------
1 | def stairs_builder(n):
2 | # build 1 step
3 | print("Осталось построить {} ступеней.".format(n))
4 | stairs_builder(n - 1)
5 |
--------------------------------------------------------------------------------
/sprint3/By languages/python/lesson2code2.py:
--------------------------------------------------------------------------------
1 | def stairs_builder(n):
2 | if n == 0:
3 | return
4 | # build 1 step
5 | print("Осталось построить {} ступеней.".format(n))
6 | stairs_builder(n - 1)
7 |
--------------------------------------------------------------------------------
/sprint3/By languages/python/lesson2code3.py:
--------------------------------------------------------------------------------
1 | def as_binary_string(n):
2 | if n < 0:
3 | return "-" + as_binary_string(-n)
4 | last_digit = n % 2
5 | return as_binary_string(n // 2) + str(last_digit)
6 |
7 |
--------------------------------------------------------------------------------
/sprint3/By languages/python/lesson2code4.py:
--------------------------------------------------------------------------------
1 | def as_binary_string(n):
2 | if n < 0:
3 | return "-" + as_binary_string(-n)
4 | if n == 0 or n == 1:
5 | return str(n)
6 | last_digit = n % 2
7 | return as_binary_string(n // 2) + str(last_digit)
--------------------------------------------------------------------------------
/sprint3/By languages/python/lesson4code1.py:
--------------------------------------------------------------------------------
1 | def gen_binary(n, prefix):
2 | if n == 0:
3 | print(prefix)
4 | else:
5 | gen_binary(n - 1, prefix + '0')
6 | gen_binary(n - 1, prefix + '1')
7 |
--------------------------------------------------------------------------------
/sprint3/By languages/python/lesson9code1.py:
--------------------------------------------------------------------------------
1 | digit_lengths = [4, 4, 3, 3, 6, 4, 5, 4, 6, 6] # длины слов «ноль», «один»,...
2 |
3 | def key_for_card(card):
4 | return [-digit_lengths[card], card]
5 |
6 | cards = [2, 3 ,7]
7 | cards.sort(key=key_for_card)
8 | print(cards)
9 |
--------------------------------------------------------------------------------
/sprint3/By languages/swift/lesson2code1.swift:
--------------------------------------------------------------------------------
1 | func stairsBuilder(n: Int) {
2 | if n > 0 {
3 | print("Осталось построить \(n) ступеней.")
4 | stairsBuilder(n: n - 1)
5 | }
6 | }
7 |
8 | stairsBuilder(n: 5)
9 | // Получим вывод:
10 | // Осталось построить 5 ступеней.
11 | // Осталось построить 4 ступеней.
12 | // Осталось построить 3 ступеней.
13 | // Осталось построить 2 ступеней.
14 | // Осталось построить 1 ступеней.
--------------------------------------------------------------------------------
/sprint3/By languages/swift/lesson2code3.swift:
--------------------------------------------------------------------------------
1 | func asBinaryString(_ n: Int) -> String {
2 | if n < 0 {
3 | return "-" + asBinaryString(-n)
4 | }
5 | let lastDigit = n % 2
6 | return asBinaryString(n / 2) + String(lastDigit)
7 | }
8 |
9 |
--------------------------------------------------------------------------------
/sprint3/By languages/swift/lesson2code4.swift:
--------------------------------------------------------------------------------
1 | func asBinaryString(_ n: Int) -> String {
2 | if n < 0 {
3 | return "-" + asBinaryString(-n)
4 | }
5 | if n == 0 || n == 1 {
6 | return String(n)
7 | }
8 | let lastDigit = n % 2
9 | return asBinaryString(n / 2) + String(lastDigit)
10 | }
11 |
--------------------------------------------------------------------------------
/sprint3/By languages/swift/lesson4code1.swift:
--------------------------------------------------------------------------------
1 | func genBinary(n: Int, prefix: String) {
2 | if n == 0 {
3 | print(prefix)
4 | } else {
5 | genBinary(n: n - 1, prefix: prefix + "0")
6 | genBinary(n: n - 1, prefix: prefix + "1")
7 | }
8 | }
9 |
10 | genBinary(n: 3, prefix: "")
11 |
--------------------------------------------------------------------------------
/sprint3/By languages/swift/lesson9code1.swift:
--------------------------------------------------------------------------------
1 | let digitLengths = [4, 4, 3, 3, 6, 4, 5, 4, 6, 6] // длины слов «ноль», «один»,...
2 |
3 | func keyForCard(_ card: Int) -> [Int] {
4 | return [-digitLengths[card], card]
5 | }
6 |
7 | var cards = [2, 3, 7]
8 | cards.sort(by: { card1, card2 in
9 | let key1 = keyForCard(card1)
10 | let key2 = keyForCard(card2)
11 | return key1.lexicographicallyPrecedes(key2)
12 | })
13 | print(cards)
--------------------------------------------------------------------------------
/sprint3/By lessons/lesson14code1/lesson14code1.go:
--------------------------------------------------------------------------------
1 | func countingSort(array []int, k int) []int {
2 | countedValues := make([]int, k)
3 | for _, value := range array {
4 | countedValues[value]++
5 | }
6 |
7 | index := 0
8 | for value := 0; value < k; value++ {
9 | for amount := 0; amount < countedValues[value]; amount++ {
10 | array[index] = value
11 | index++
12 | }
13 | }
14 | return array
15 | }
16 |
--------------------------------------------------------------------------------
/sprint3/By lessons/lesson14code1/lesson14code1.kt:
--------------------------------------------------------------------------------
1 | fun countingSort(array: IntArray, k: Int): IntArray {
2 | val countedValues = IntArray(k) { 0 }
3 | for (value in array) {
4 | countedValues[value]++
5 | }
6 |
7 | var index = 0
8 | for (value in 0 until k) {
9 | for (amount in 1..countedValues[value]) {
10 | array[index] = value
11 | index++
12 | }
13 | }
14 | return array
15 | }
16 |
--------------------------------------------------------------------------------
/sprint3/By lessons/lesson14code1/lesson14code1.py:
--------------------------------------------------------------------------------
1 | def counting_sort(array, k):
2 | counted_values = [0] * k
3 | for value in array:
4 | counted_values[value] += 1
5 |
6 | index = 0
7 | for value in range(k):
8 | for amount in range(counted_values[value]):
9 | array[index] = value
10 | index += 1
11 | return array
12 |
--------------------------------------------------------------------------------
/sprint3/By lessons/lesson2code1/lesson2code1.cpp:
--------------------------------------------------------------------------------
1 | #include
2 |
3 | void stairs_builder(int n) {
4 | // build 1 step
5 | std::cout << "Осталось построить " << n << " ступеней." << std::endl;
6 | stairs_builder(n - 1);
7 | }
8 |
9 | int main() {
10 | stairs_builder(5);
11 | return 0;
12 | }
13 |
--------------------------------------------------------------------------------
/sprint3/By lessons/lesson2code1/lesson2code1.cs:
--------------------------------------------------------------------------------
1 | using System;
2 |
3 | class Program {
4 | static void stairs_builder(int n) {
5 | // build 1 step
6 | Console.WriteLine($"Осталось построить {n} ступеней.");
7 | stairs_builder(n - 1);
8 | }
9 |
10 | static void Main(string[] args) {
11 | stairs_builder(5);
12 | }
13 | }
14 |
--------------------------------------------------------------------------------
/sprint3/By lessons/lesson2code1/lesson2code1.go:
--------------------------------------------------------------------------------
1 | package main
2 |
3 | import "fmt"
4 |
5 | func stairsBuilder(n int) {
6 | // build 1 step
7 | fmt.Printf("Осталось построить %d ступеней.\n", n)
8 | stairsBuilder(n - 1)
9 | }
10 |
11 | func main() {
12 | stairsBuilder(5)
13 | }
14 |
--------------------------------------------------------------------------------
/sprint3/By lessons/lesson2code1/lesson2code1.java:
--------------------------------------------------------------------------------
1 | class Main {
2 | static void stairs_builder(int n) {
3 | // build 1 step
4 | System.out.printf("Осталось построить %d ступеней.\n", n);
5 | stairs_builder(n - 1);
6 | }
7 |
8 | public static void main(String[] args) {
9 | stairs_builder(5);
10 | }
11 | }
12 |
--------------------------------------------------------------------------------
/sprint3/By lessons/lesson2code1/lesson2code1.js:
--------------------------------------------------------------------------------
1 | function stairs_builder(n) {
2 | // build 1 step
3 | console.log(`Осталось построить ${n} ступеней.`);
4 | stairs_builder(n - 1);
5 | }
6 |
7 | stairs_builder(5);
8 |
--------------------------------------------------------------------------------
/sprint3/By lessons/lesson2code1/lesson2code1.kt:
--------------------------------------------------------------------------------
1 | fun stairs_builder(n: Int) {
2 | // build 1 step
3 | println("Осталось построить $n ступеней.")
4 | stairs_builder(n - 1)
5 | }
6 |
--------------------------------------------------------------------------------
/sprint3/By lessons/lesson2code1/lesson2code1.py:
--------------------------------------------------------------------------------
1 | def stairs_builder(n):
2 | # build 1 step
3 | print("Осталось построить {} ступеней.".format(n))
4 | stairs_builder(n - 1)
5 |
--------------------------------------------------------------------------------
/sprint3/By lessons/lesson2code2/lesson2code2.cpp:
--------------------------------------------------------------------------------
1 | #include
2 |
3 | void stairs_builder(int n) {
4 | if (n == 0) {
5 | return;
6 | }
7 | // build 1 step
8 | std::cout << "Осталось построить " << n << " ступеней." << std::endl;
9 | stairs_builder(n - 1);
10 | }
11 |
12 | int main() {
13 | stairs_builder(5);
14 | return 0;
15 | }
16 |
--------------------------------------------------------------------------------
/sprint3/By lessons/lesson2code2/lesson2code2.cs:
--------------------------------------------------------------------------------
1 | using System;
2 |
3 | class Program {
4 | static void stairs_builder(int n) {
5 | if (n == 0) {
6 | return;
7 | }
8 | // build 1 step
9 | Console.WriteLine($"Осталось построить {n} ступеней.");
10 | stairs_builder(n - 1);
11 | }
12 |
13 | static void Main(string[] args) {
14 | stairs_builder(5);
15 | }
16 | }
17 |
--------------------------------------------------------------------------------
/sprint3/By lessons/lesson2code2/lesson2code2.go:
--------------------------------------------------------------------------------
1 | package main
2 |
3 | import "fmt"
4 |
5 | func stairsBuilder(n int) {
6 | if n == 0 {
7 | return
8 | }
9 | // build 1 step
10 | fmt.Printf("Осталось построить %d ступеней.\n", n)
11 | stairsBuilder(n - 1)
12 | }
13 |
14 | func main() {
15 | stairsBuilder(5)
16 | }
17 |
--------------------------------------------------------------------------------
/sprint3/By lessons/lesson2code2/lesson2code2.java:
--------------------------------------------------------------------------------
1 | class Main {
2 | static void stairs_builder(int n) {
3 | if (n == 0) {
4 | return;
5 | }
6 | // build 1 step
7 | System.out.printf("Осталось построить %d ступеней.\n", n);
8 | stairs_builder(n - 1);
9 | }
10 |
11 | public static void main(String[] args) {
12 | stairs_builder(5);
13 | }
14 | }
15 |
--------------------------------------------------------------------------------
/sprint3/By lessons/lesson2code2/lesson2code2.js:
--------------------------------------------------------------------------------
1 | function stairs_builder(n) {
2 | if (n === 0) {
3 | return;
4 | }
5 | // build 1 step
6 | console.log(`Осталось построить ${n} ступеней.`);
7 | stairs_builder(n - 1);
8 | }
9 |
10 | stairs_builder(5);
11 |
--------------------------------------------------------------------------------
/sprint3/By lessons/lesson2code2/lesson2code2.kt:
--------------------------------------------------------------------------------
1 | fun stairs_builder(n: Int) {
2 | if (n == 0) return
3 | // build 1 step
4 | println("Осталось построить $n ступеней.")
5 | stairs_builder(n - 1)
6 | }
7 |
--------------------------------------------------------------------------------
/sprint3/By lessons/lesson2code2/lesson2code2.py:
--------------------------------------------------------------------------------
1 | def stairs_builder(n):
2 | if n == 0:
3 | return
4 | # build 1 step
5 | print("Осталось построить {} ступеней.".format(n))
6 | stairs_builder(n - 1)
7 |
--------------------------------------------------------------------------------
/sprint3/By lessons/lesson2code3/lesson2code3.cpp:
--------------------------------------------------------------------------------
1 | #include
2 |
3 | std::string as_binary_string(int n) {
4 | if (n < 0) {
5 | return "-" + as_binary_string(-n);
6 | }
7 | int last_digit = n % 2;
8 | return as_binary_string(n / 2) + std::to_string(last_digit);
9 | }
10 |
--------------------------------------------------------------------------------
/sprint3/By lessons/lesson2code3/lesson2code3.cs:
--------------------------------------------------------------------------------
1 | public static string AsBinaryString(int n)
2 | {
3 | if (n < 0)
4 | return "-" + AsBinaryString(-n);
5 | int lastDigit = n % 2;
6 | return AsBinaryString(n / 2) + lastDigit.ToString();
7 | }
8 |
--------------------------------------------------------------------------------
/sprint3/By lessons/lesson2code3/lesson2code3.go:
--------------------------------------------------------------------------------
1 | func asBinaryString(n int) string {
2 | if n < 0 {
3 | return "-" + asBinaryString(-n)
4 | }
5 | lastDigit := n % 2
6 | return asBinaryString(n / 2) + strconv.Itoa(lastDigit)
7 | }
8 |
--------------------------------------------------------------------------------
/sprint3/By lessons/lesson2code3/lesson2code3.java:
--------------------------------------------------------------------------------
1 | public static String asBinaryString(int n) {
2 | if (n < 0) {
3 | return "-" + asBinaryString(-n);
4 | }
5 | int lastDigit = n % 2;
6 | return asBinaryString(n / 2) + Integer.toString(lastDigit);
7 | }
8 |
--------------------------------------------------------------------------------
/sprint3/By lessons/lesson2code3/lesson2code3.js:
--------------------------------------------------------------------------------
1 | function as_binary_string(n) {
2 | if (n < 0) {
3 | return "-" + as_binary_string(-n);
4 | }
5 | let last_digit = n % 2;
6 | return as_binary_string(Math.floor(n / 2)) + last_digit.toString();
7 | }
8 |
--------------------------------------------------------------------------------
/sprint3/By lessons/lesson2code3/lesson2code3.kt:
--------------------------------------------------------------------------------
1 | fun as_binary_string(n: Int): String {
2 | if (n < 0) return "-" + as_binary_string(-n)
3 | val lastDigit = n % 2
4 | return as_binary_string(n / 2) + lastDigit.toString()
5 | }
--------------------------------------------------------------------------------
/sprint3/By lessons/lesson2code3/lesson2code3.py:
--------------------------------------------------------------------------------
1 | def as_binary_string(n):
2 | if n < 0:
3 | return "-" + as_binary_string(-n)
4 | last_digit = n % 2
5 | return as_binary_string(n // 2) + str(last_digit)
6 |
7 |
--------------------------------------------------------------------------------
/sprint3/By lessons/lesson2code3/lesson2code3.swift:
--------------------------------------------------------------------------------
1 | func asBinaryString(_ n: Int) -> String {
2 | if n < 0 {
3 | return "-" + asBinaryString(-n)
4 | }
5 | let lastDigit = n % 2
6 | return asBinaryString(n / 2) + String(lastDigit)
7 | }
8 |
9 |
--------------------------------------------------------------------------------
/sprint3/By lessons/lesson2code4/lesson2code4.cpp:
--------------------------------------------------------------------------------
1 | #include
2 |
3 | std::string as_binary_string(int n) {
4 | if (n < 0) {
5 | return "-" + as_binary_string(-n);
6 | }
7 | if (n == 0 || n == 1) {
8 | return std::to_string(n);
9 | }
10 | int last_digit = n % 2;
11 | return as_binary_string(n / 2) + std::to_string(last_digit);
12 | }
13 |
--------------------------------------------------------------------------------
/sprint3/By lessons/lesson2code4/lesson2code4.cs:
--------------------------------------------------------------------------------
1 | public static string AsBinaryString(int n)
2 | {
3 | if (n < 0)
4 | return "-" + AsBinaryString(-n);
5 | if (n == 0 || n == 1)
6 | return n.ToString();
7 | int lastDigit = n % 2;
8 | return AsBinaryString(n / 2) + lastDigit.ToString();
9 | }
10 |
--------------------------------------------------------------------------------
/sprint3/By lessons/lesson2code4/lesson2code4.go:
--------------------------------------------------------------------------------
1 | func asBinaryString(n int) string {
2 | if n < 0 {
3 | return "-" + asBinaryString(-n)
4 | }
5 | if n == 0 || n == 1 {
6 | return strconv.Itoa(n)
7 | }
8 | lastDigit := n % 2
9 | return asBinaryString(n / 2) + strconv.Itoa(lastDigit)
10 | }
11 |
--------------------------------------------------------------------------------
/sprint3/By lessons/lesson2code4/lesson2code4.java:
--------------------------------------------------------------------------------
1 | public static String asBinaryString(int n) {
2 | if (n < 0) {
3 | return "-" + asBinaryString(-n);
4 | }
5 | if (n == 0 || n == 1) {
6 | return Integer.toString(n);
7 | }
8 | int lastDigit = n % 2;
9 | return asBinaryString(n / 2) + Integer.toString(lastDigit);
10 | }
11 |
--------------------------------------------------------------------------------
/sprint3/By lessons/lesson2code4/lesson2code4.js:
--------------------------------------------------------------------------------
1 | function as_binary_string(n) {
2 | if (n < 0) {
3 | return "-" + as_binary_string(-n);
4 | }
5 | if (n == 0 || n == 1) {
6 | return n.toString();
7 | }
8 | let last_digit = n % 2;
9 | return as_binary_string(Math.floor(n / 2)) + last_digit.toString();
10 | }
11 |
--------------------------------------------------------------------------------
/sprint3/By lessons/lesson2code4/lesson2code4.kt:
--------------------------------------------------------------------------------
1 | fun as_binary_string(n: Int): String {
2 | if (n < 0) return "-" + as_binary_string(-n)
3 | if (n == 0 || n == 1) return n.toString()
4 | val lastDigit = n % 2
5 | return as_binary_string(n / 2) + lastDigit.toString()
6 | }
--------------------------------------------------------------------------------
/sprint3/By lessons/lesson2code4/lesson2code4.py:
--------------------------------------------------------------------------------
1 | def as_binary_string(n):
2 | if n < 0:
3 | return "-" + as_binary_string(-n)
4 | if n == 0 or n == 1:
5 | return str(n)
6 | last_digit = n % 2
7 | return as_binary_string(n // 2) + str(last_digit)
--------------------------------------------------------------------------------
/sprint3/By lessons/lesson2code4/lesson2code4.swift:
--------------------------------------------------------------------------------
1 | func asBinaryString(_ n: Int) -> String {
2 | if n < 0 {
3 | return "-" + asBinaryString(-n)
4 | }
5 | if n == 0 || n == 1 {
6 | return String(n)
7 | }
8 | let lastDigit = n % 2
9 | return asBinaryString(n / 2) + String(lastDigit)
10 | }
11 |
--------------------------------------------------------------------------------
/sprint3/By lessons/lesson4code1/lesson4code1.cpp:
--------------------------------------------------------------------------------
1 | #include
2 | using namespace std;
3 |
4 | void gen_binary(int n, string prefix) {
5 | if (n == 0) {
6 | cout << prefix << endl;
7 | } else {
8 | gen_binary(n - 1, prefix + "0");
9 | gen_binary(n - 1, prefix + "1");
10 | }
11 | }
12 |
13 | int main() {
14 | gen_binary(3, "");
15 | return 0;
16 | }
17 |
--------------------------------------------------------------------------------
/sprint3/By lessons/lesson4code1/lesson4code1.go:
--------------------------------------------------------------------------------
1 | package main
2 |
3 | import "fmt"
4 |
5 | func main() {
6 | genBinary(3, "")
7 | }
8 |
9 | func genBinary(n int, prefix string) {
10 | if n == 0 {
11 | fmt.Println(prefix)
12 | } else {
13 | genBinary(n-1, prefix+"0")
14 | genBinary(n-1, prefix+"1")
15 | }
16 | }
17 |
--------------------------------------------------------------------------------
/sprint3/By lessons/lesson4code1/lesson4code1.java:
--------------------------------------------------------------------------------
1 | public class Main {
2 | public static void main(String[] args) {
3 | genBinary(3, "");
4 | }
5 |
6 | static void genBinary(int n, String prefix) {
7 | if (n == 0) {
8 | System.out.println(prefix);
9 | } else {
10 | genBinary(n - 1, prefix + "0");
11 | genBinary(n - 1, prefix + "1");
12 | }
13 | }
14 | }
15 |
--------------------------------------------------------------------------------
/sprint3/By lessons/lesson4code1/lesson4code1.js:
--------------------------------------------------------------------------------
1 | function genBinary(n, prefix) {
2 | if (n == 0) {
3 | console.log(prefix);
4 | } else {
5 | genBinary(n - 1, prefix + "0");
6 | genBinary(n - 1, prefix + "1");
7 | }
8 | }
9 |
10 | genBinary(3, "");
11 |
--------------------------------------------------------------------------------
/sprint3/By lessons/lesson4code1/lesson4code1.kt:
--------------------------------------------------------------------------------
1 | fun genBinary(n: Int, prefix: String) {
2 | if (n == 0) {
3 | println(prefix)
4 | } else {
5 | genBinary(n - 1, prefix + "0")
6 | genBinary(n - 1, prefix + "1")
7 | }
8 | }
9 |
--------------------------------------------------------------------------------
/sprint3/By lessons/lesson4code1/lesson4code1.py:
--------------------------------------------------------------------------------
1 | def gen_binary(n, prefix):
2 | if n == 0:
3 | print(prefix)
4 | else:
5 | gen_binary(n - 1, prefix + '0')
6 | gen_binary(n - 1, prefix + '1')
7 |
--------------------------------------------------------------------------------
/sprint3/By lessons/lesson4code1/lesson4code1.swift:
--------------------------------------------------------------------------------
1 | func genBinary(n: Int, prefix: String) {
2 | if n == 0 {
3 | print(prefix)
4 | } else {
5 | genBinary(n: n - 1, prefix: prefix + "0")
6 | genBinary(n: n - 1, prefix: prefix + "1")
7 | }
8 | }
9 |
10 | genBinary(n: 3, prefix: "")
11 |
--------------------------------------------------------------------------------
/sprint3/By lessons/lesson9code1/lesson9code1.js:
--------------------------------------------------------------------------------
1 | let digit_lengths = [4, 4, 3, 3, 6, 4, 5, 4, 6, 6]; // длины слов «ноль», «один»,...
2 |
3 | function key_for_card(card) {
4 | return [-digit_lengths[card], card];
5 | }
6 |
7 | let cards = [2, 3, 7];
8 | cards.sort((a, b) => key_for_card(a) < key_for_card(b) ? -1 : 1);
9 | console.log(cards);
10 |
--------------------------------------------------------------------------------
/sprint3/By lessons/lesson9code1/lesson9code1.kt:
--------------------------------------------------------------------------------
1 | val digitLengths = intArrayOf(4, 4, 3, 3, 6, 4, 5, 4, 6, 6) // длины слов «ноль», «один»,...
2 |
3 | fun keyForCard(card: Int): List {
4 | return listOf(-digitLengths[card], card)
5 | }
6 |
7 | val cards = intArrayOf(2, 3 ,7)
8 | cards.sortBy { keyForCard(it) }
9 | println(cards.toList())
10 |
--------------------------------------------------------------------------------
/sprint3/By lessons/lesson9code1/lesson9code1.py:
--------------------------------------------------------------------------------
1 | digit_lengths = [4, 4, 3, 3, 6, 4, 5, 4, 6, 6] # длины слов «ноль», «один»,...
2 |
3 | def key_for_card(card):
4 | return [-digit_lengths[card], card]
5 |
6 | cards = [2, 3 ,7]
7 | cards.sort(key=key_for_card)
8 | print(cards)
9 |
--------------------------------------------------------------------------------
/sprint4/By languages/JS/lesson10code1.js:
--------------------------------------------------------------------------------
1 | function naiveSolution(A, x) {
2 | const n = x.length;
3 | const triples = [];
4 | for (let i1 = 0; i1 < n; i1++) {
5 | for (let i2 = i1 + 1; i2 < n; i2++) {
6 | for (let i3 = i2 + 1; i3 < n; i3++) {
7 | if (x[i1] + x[i2] + x[i3] === A) {
8 | triples.push([x[i1], x[i2], x[i3]]);
9 | }
10 | }
11 | }
12 | }
13 | return triples;
14 | }
15 |
--------------------------------------------------------------------------------
/sprint4/By languages/JS/lesson1code2.js:
--------------------------------------------------------------------------------
1 | // Словарь "статистика посещения страниц"
2 | const pagesVisitStats = {
3 | "https://timofey.me": {
4 | "main": 2,
5 | "contacts": 3
6 | },
7 | "https://fruit-shop.ru": {
8 | "apples": 12,
9 | "plums": 10,
10 | "pears": 20,
11 | "contacts": 15
12 | }
13 | };
14 |
15 | const siteStats = pagesVisitStats["https://timofey.me"];
16 |
--------------------------------------------------------------------------------
/sprint4/By languages/JS/lesson1code3.js:
--------------------------------------------------------------------------------
1 | const fruits = ["яблоко", "яблоко", "груша", "яблоко", "слива"];
2 | const fruitCount = new Map();
3 | for (const fruit of fruits) {
4 | if (!fruitCount.has(fruit)) {
5 | fruitCount.set(fruit, 0);
6 | }
7 | fruitCount.set(fruit, fruitCount.get(fruit) + 1);
8 | }
9 |
--------------------------------------------------------------------------------
/sprint4/By languages/Java/lesson1code3.java:
--------------------------------------------------------------------------------
1 | List fruits = Arrays.asList("яблоко", "яблоко", "груша", "яблоко", "слива");
2 | Map fruitCount = new HashMap<>();
3 | for (String fruit : fruits) {
4 | if (!fruitCount.containsKey(fruit)) {
5 | fruitCount.put(fruit, 0);
6 | }
7 | fruitCount.put(fruit, fruitCount.get(fruit) + 1);
8 | }
9 |
--------------------------------------------------------------------------------
/sprint4/By languages/kotlin/lesson2code1.kt:
--------------------------------------------------------------------------------
1 | // функция bucket вычисляет номер корзины для указанного фрукта
2 | fun bucket(fruit: String): Int {
3 | return when (fruit) {
4 | "яблоко" -> 0
5 | "слива" -> 1
6 | "груша" -> 2
7 | else -> throw IllegalArgumentException("Unknown fruit")
8 | }
9 | }
10 |
--------------------------------------------------------------------------------
/sprint4/By languages/python/lesson10code1.py:
--------------------------------------------------------------------------------
1 | def naive_solution(A, x):
2 | n = len(x)
3 | triples = []
4 | for i1 in range(n):
5 | for i2 in range(i1 + 1, n):
6 | for i3 in range(i2 + 1, n):
7 | if x[i1] + x[i2] + x[i3] == A:
8 | triples.append((x[i1], x[i2], x[i3]))
9 | return triples
10 |
--------------------------------------------------------------------------------
/sprint4/By languages/python/lesson1code2.py:
--------------------------------------------------------------------------------
1 | # Словарь "статистика посещения страниц"
2 | pages_visit_stats = {
3 | "https://timofey.me": {
4 | "main": 2,
5 | "contacts": 3
6 | },
7 | "https://fruit-shop.ru": {
8 | "apples": 12,
9 | "plums": 10,
10 | "pears": 20,
11 | "contacts": 15
12 | }
13 | }
14 |
15 | site_stats = pages_visit_stats["https://timofey.me"]
16 |
--------------------------------------------------------------------------------
/sprint4/By languages/python/lesson1code3.py:
--------------------------------------------------------------------------------
1 | fruits = ["яблоко", "яблоко", "груша", "яблоко", "слива"]
2 | fruitCount = {}
3 | for fruit in fruits:
4 | if fruit not in fruitCount:
5 | fruitCount[fruit] = 0
6 | fruitCount[fruit] += 1
7 |
--------------------------------------------------------------------------------
/sprint4/By languages/swift/lesson1code2.swift:
--------------------------------------------------------------------------------
1 | // Словарь "статистика посещения страниц"
2 | var pagesVisitStats = [
3 | "https://timofey.me": [
4 | "main": 2,
5 | "contacts": 3
6 | ],
7 | "https://fruit-shop.ru": [
8 | "apples": 12,
9 | "plums": 10,
10 | "pears": 20,
11 | "contacts": 15
12 | ]
13 | ]
14 |
15 | let siteStats = pagesVisitStats["https://timofey.me"]
16 |
--------------------------------------------------------------------------------
/sprint4/By languages/swift/lesson1code3.swift:
--------------------------------------------------------------------------------
1 | var fruits = ["яблоко", "яблоко", "груша", "яблоко", "слива"]
2 | var fruitCount: [String: Int] = [:]
3 |
4 | for fruit in fruits {
5 | if fruitCount[fruit] == nil {
6 | fruitCount[fruit] = 0
7 | }
8 | fruitCount[fruit]! += 1
9 | }
10 |
--------------------------------------------------------------------------------
/sprint4/By lessons/lesson10code1/lesson10code1.js:
--------------------------------------------------------------------------------
1 | function naiveSolution(A, x) {
2 | const n = x.length;
3 | const triples = [];
4 | for (let i1 = 0; i1 < n; i1++) {
5 | for (let i2 = i1 + 1; i2 < n; i2++) {
6 | for (let i3 = i2 + 1; i3 < n; i3++) {
7 | if (x[i1] + x[i2] + x[i3] === A) {
8 | triples.push([x[i1], x[i2], x[i3]]);
9 | }
10 | }
11 | }
12 | }
13 | return triples;
14 | }
15 |
--------------------------------------------------------------------------------
/sprint4/By lessons/lesson10code1/lesson10code1.py:
--------------------------------------------------------------------------------
1 | def naive_solution(A, x):
2 | n = len(x)
3 | triples = []
4 | for i1 in range(n):
5 | for i2 in range(i1 + 1, n):
6 | for i3 in range(i2 + 1, n):
7 | if x[i1] + x[i2] + x[i3] == A:
8 | triples.append((x[i1], x[i2], x[i3]))
9 | return triples
10 |
--------------------------------------------------------------------------------
/sprint4/By lessons/lesson1code2/lesson1code2.js:
--------------------------------------------------------------------------------
1 | // Словарь "статистика посещения страниц"
2 | const pagesVisitStats = {
3 | "https://timofey.me": {
4 | "main": 2,
5 | "contacts": 3
6 | },
7 | "https://fruit-shop.ru": {
8 | "apples": 12,
9 | "plums": 10,
10 | "pears": 20,
11 | "contacts": 15
12 | }
13 | };
14 |
15 | const siteStats = pagesVisitStats["https://timofey.me"];
16 |
--------------------------------------------------------------------------------
/sprint4/By lessons/lesson1code2/lesson1code2.py:
--------------------------------------------------------------------------------
1 | # Словарь "статистика посещения страниц"
2 | pages_visit_stats = {
3 | "https://timofey.me": {
4 | "main": 2,
5 | "contacts": 3
6 | },
7 | "https://fruit-shop.ru": {
8 | "apples": 12,
9 | "plums": 10,
10 | "pears": 20,
11 | "contacts": 15
12 | }
13 | }
14 |
15 | site_stats = pages_visit_stats["https://timofey.me"]
16 |
--------------------------------------------------------------------------------
/sprint4/By lessons/lesson1code2/lesson1code2.swift:
--------------------------------------------------------------------------------
1 | // Словарь "статистика посещения страниц"
2 | var pagesVisitStats = [
3 | "https://timofey.me": [
4 | "main": 2,
5 | "contacts": 3
6 | ],
7 | "https://fruit-shop.ru": [
8 | "apples": 12,
9 | "plums": 10,
10 | "pears": 20,
11 | "contacts": 15
12 | ]
13 | ]
14 |
15 | let siteStats = pagesVisitStats["https://timofey.me"]
16 |
--------------------------------------------------------------------------------
/sprint4/By lessons/lesson1code3/lesson1code3.java:
--------------------------------------------------------------------------------
1 | List fruits = Arrays.asList("яблоко", "яблоко", "груша", "яблоко", "слива");
2 | Map fruitCount = new HashMap<>();
3 | for (String fruit : fruits) {
4 | if (!fruitCount.containsKey(fruit)) {
5 | fruitCount.put(fruit, 0);
6 | }
7 | fruitCount.put(fruit, fruitCount.get(fruit) + 1);
8 | }
9 |
--------------------------------------------------------------------------------
/sprint4/By lessons/lesson1code3/lesson1code3.js:
--------------------------------------------------------------------------------
1 | const fruits = ["яблоко", "яблоко", "груша", "яблоко", "слива"];
2 | const fruitCount = new Map();
3 | for (const fruit of fruits) {
4 | if (!fruitCount.has(fruit)) {
5 | fruitCount.set(fruit, 0);
6 | }
7 | fruitCount.set(fruit, fruitCount.get(fruit) + 1);
8 | }
9 |
--------------------------------------------------------------------------------
/sprint4/By lessons/lesson1code3/lesson1code3.py:
--------------------------------------------------------------------------------
1 | fruits = ["яблоко", "яблоко", "груша", "яблоко", "слива"]
2 | fruitCount = {}
3 | for fruit in fruits:
4 | if fruit not in fruitCount:
5 | fruitCount[fruit] = 0
6 | fruitCount[fruit] += 1
7 |
--------------------------------------------------------------------------------
/sprint4/By lessons/lesson1code3/lesson1code3.swift:
--------------------------------------------------------------------------------
1 | var fruits = ["яблоко", "яблоко", "груша", "яблоко", "слива"]
2 | var fruitCount: [String: Int] = [:]
3 |
4 | for fruit in fruits {
5 | if fruitCount[fruit] == nil {
6 | fruitCount[fruit] = 0
7 | }
8 | fruitCount[fruit]! += 1
9 | }
10 |
--------------------------------------------------------------------------------
/sprint4/By lessons/lesson2code1/lesson2code1.cpp:
--------------------------------------------------------------------------------
1 | // Функция bucket вычисляет номер корзины для указанного фрукта
2 | int bucket(std::string fruit) {
3 | if (fruit == "яблоко") {
4 | return 0;
5 | } else if (fruit == "слива") {
6 | return 1;
7 | } else if (fruit == "груша") {
8 | return 2;
9 | } else {
10 | throw std::invalid_argument("Неизвестный фрукт");
11 | }
12 | }
13 |
--------------------------------------------------------------------------------
/sprint4/By lessons/lesson2code1/lesson2code1.go:
--------------------------------------------------------------------------------
1 | // Функция bucket вычисляет номер корзины для указанного фрукта
2 | func bucket(fruit string) int {
3 | switch fruit {
4 | case "яблоко":
5 | return 0
6 | case "слива":
7 | return 1
8 | case "груша":
9 | return 2
10 | default:
11 | panic("Неизвестный фрукт")
12 | }
13 | }
14 |
--------------------------------------------------------------------------------
/sprint4/By lessons/lesson2code1/lesson2code1.js:
--------------------------------------------------------------------------------
1 | // Функция bucket вычисляет номер корзины для указанного фрукта
2 | function bucket(fruit) {
3 | switch (fruit) {
4 | case "яблоко":
5 | return 0;
6 | case "слива":
7 | return 1;
8 | case "груша":
9 | return 2;
10 | default:
11 | throw new Error("Неизвестный фрукт");
12 | }
13 | }
14 |
--------------------------------------------------------------------------------
/sprint4/By lessons/lesson2code1/lesson2code1.kt:
--------------------------------------------------------------------------------
1 | // функция bucket вычисляет номер корзины для указанного фрукта
2 | fun bucket(fruit: String): Int {
3 | return when (fruit) {
4 | "яблоко" -> 0
5 | "слива" -> 1
6 | "груша" -> 2
7 | else -> throw IllegalArgumentException("Неизвестный фрукт")
8 | }
9 | }
10 |
--------------------------------------------------------------------------------
/sprint4/By lessons/lesson2code1/lesson2code1.py:
--------------------------------------------------------------------------------
1 | # Функция bucket вычисляет номер корзины для указанного фрукта
2 | def bucket(fruit):
3 | if fruit == "яблоко":
4 | return 0
5 | elif fruit == "слива":
6 | return 1
7 | elif fruit == "груша":
8 | return 2
9 | else:
10 | raise ValueError("Неизвестный фрукт")
11 |
--------------------------------------------------------------------------------
/sprint4/By lessons/lesson2code1/lesson2code1.swift:
--------------------------------------------------------------------------------
1 | // Функция bucket вычисляет номер корзины для указанного фрукта
2 | func bucket(fruit: String) -> Int {
3 | switch fruit {
4 | case "яблоко":
5 | return 0
6 | case "слива":
7 | return 1
8 | case "груша":
9 | return 2
10 | default:
11 | fatalError("Неизвестный фрукт")
12 | }
13 | }
14 |
--------------------------------------------------------------------------------
/sprint5/.DS_Store:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Yandex-Practicum/algorithms-theory-examples/08897e044bc38ebf6e5fd810b2aed76a32698b3a/sprint5/.DS_Store
--------------------------------------------------------------------------------
/sprint5/By languages/C#/lesson2code1.cs:
--------------------------------------------------------------------------------
1 | using System.Collections.Generic;
2 |
3 | public class Node {
4 | public int Obj { get; set; }
5 | public List Children { get; set; }
6 |
7 | public Node(int obj, List children = null) {
8 | Obj = obj;
9 | Children = children ?? new List();
10 | }
11 | }
12 |
--------------------------------------------------------------------------------
/sprint5/By languages/C#/lesson2code2.cs:
--------------------------------------------------------------------------------
1 | public class Node {
2 | public Node(int obj, Node left = null, Node right = null) {
3 | this.obj = obj;
4 | this.left = left;
5 | this.right = right;
6 | }
7 | public int obj;
8 | public Node left;
9 | public Node right;
10 | }
11 |
--------------------------------------------------------------------------------
/sprint5/By languages/C#/lesson3code1.cs:
--------------------------------------------------------------------------------
1 | Node FindNode(Node root, int value) {
2 | if (root == null) {
3 | return null;
4 | }
5 | if (value < root.Value) {
6 | return FindNode(root.Left, value);
7 | }
8 | if (value == root.Value) {
9 | return root;
10 | }
11 | if (value > root.Value) {
12 | return FindNode(root.Right, value);
13 | }
14 | }
15 |
--------------------------------------------------------------------------------
/sprint5/By languages/C#/lesson4code1.cs:
--------------------------------------------------------------------------------
1 | void PrintForward(Node vertex) {
2 | Console.WriteLine(vertex.Value);
3 | foreach (Node child in vertex.Children) {
4 | PrintForward(child);
5 | }
6 | }
7 |
--------------------------------------------------------------------------------
/sprint5/By languages/C#/lesson4code2.cs:
--------------------------------------------------------------------------------
1 | void PrintReversed(Node vertex) {
2 | foreach (var child in vertex.children) {
3 | PrintReversed(child);
4 | }
5 | Console.WriteLine(vertex.value);
6 | }
7 |
--------------------------------------------------------------------------------
/sprint5/By languages/C#/lesson4code3.cs:
--------------------------------------------------------------------------------
1 | void print_LMR(Node vertex) {
2 | if (vertex.left != null) {
3 | print_LMR(vertex.left);
4 | }
5 | Console.WriteLine(vertex.value);
6 | if (vertex.right != null) {
7 | print_LMR(vertex.right);
8 | }
9 | }
10 |
--------------------------------------------------------------------------------
/sprint5/By languages/C#/lesson5code1.cs:
--------------------------------------------------------------------------------
1 | void insert_node(Node root, int key) {
2 | if (key < root.key) {
3 | if (root.left == null) {
4 | root.left = new Node(key);
5 | } else {
6 | insert_node(root.left, key);
7 | }
8 | } else {
9 | if (root.right == null) {
10 | root.right = new Node(key);
11 | } else {
12 | insert_node(root.right, key);
13 | }
14 | }
15 | }
16 |
--------------------------------------------------------------------------------
/sprint5/By languages/C#/lesson8code1.cs:
--------------------------------------------------------------------------------
1 | class Node {
2 | public int key;
3 | public int height;
4 | public Node left;
5 | public Node right;
6 |
7 | public Node(int k, int h=1, Node l=null, Node r=null) {
8 | key = k;
9 | height = h;
10 | left = l;
11 | right = r;
12 | }
13 | }
14 |
--------------------------------------------------------------------------------
/sprint5/By languages/C#/lesson8code3.cs:
--------------------------------------------------------------------------------
1 | Node BigLeftRotation(Node a) {
2 | Node b = a.right;
3 | Node c = b.left;
4 | Node M = c.left;
5 | Node N = c.right;
6 |
7 | a.right = M;
8 | b.left = N;
9 | c.left = a;
10 | c.right = b;
11 |
12 | a.height -= 2;
13 | b.height -= 1;
14 | c.height += 1;
15 | return c;
16 | }
17 |
--------------------------------------------------------------------------------
/sprint5/By languages/C#/lesson8code4.cs:
--------------------------------------------------------------------------------
1 | Node BigLeftRotation(Node v) {
2 | // Правым ребёнком становится новый корень правого поддерева.
3 | v.right = SmallRightRotation(v.right);
4 | // Возвращаем новый корень поддерева.
5 | return SmallLeftRotation(v);
6 | }
7 |
--------------------------------------------------------------------------------
/sprint5/By languages/C++/lesson2code1.cpp:
--------------------------------------------------------------------------------
1 | #include
2 |
3 | class Node {
4 | public:
5 | Node(int obj, std::vector children = {}): obj(obj), children(children) {}
6 | int obj;
7 | std::vector children;
8 | };
9 |
--------------------------------------------------------------------------------
/sprint5/By languages/C++/lesson2code2.cpp:
--------------------------------------------------------------------------------
1 | class Node {
2 | public:
3 | Node(int obj, Node* left = nullptr, Node* right = nullptr)
4 | : obj(obj), left(left), right(right) {}
5 | int obj;
6 | Node* left;
7 | Node* right;
8 | };
9 |
--------------------------------------------------------------------------------
/sprint5/By languages/C++/lesson3code1.cpp:
--------------------------------------------------------------------------------
1 | Node* find_node(Node* root, int value) {
2 | if (root == nullptr) {
3 | return nullptr;
4 | }
5 | if (value < root->value) {
6 | return find_node(root->left, value);
7 | }
8 | if (value == root->value) {
9 | return root;
10 | }
11 | if (value > root->value) {
12 | return find_node(root->right, value);
13 | }
14 | }
15 |
--------------------------------------------------------------------------------
/sprint5/By languages/C++/lesson4code1.cpp:
--------------------------------------------------------------------------------
1 | void print_forward(Node* vertex) {
2 | std::cout << vertex->value << std::endl;
3 | for (Node* child : vertex->children) {
4 | print_forward(child);
5 | }
6 | }
7 |
--------------------------------------------------------------------------------
/sprint5/By languages/C++/lesson4code2.cpp:
--------------------------------------------------------------------------------
1 | void print_reversed(Node* vertex) {
2 | for (auto child : vertex->children) {
3 | print_reversed(child);
4 | }
5 | std::cout << vertex->value << std::endl;
6 | }
7 |
--------------------------------------------------------------------------------
/sprint5/By languages/C++/lesson4code3.cpp:
--------------------------------------------------------------------------------
1 | void print_LMR(Node* vertex) {
2 | if (vertex->left != nullptr) {
3 | print_LMR(vertex->left);
4 | }
5 | std::cout << vertex->value << std::endl;
6 | if (vertex->right != nullptr) {
7 | print_LMR(vertex->right);
8 | }
9 | }
10 |
--------------------------------------------------------------------------------
/sprint5/By languages/C++/lesson5code1.cpp:
--------------------------------------------------------------------------------
1 | void insert_node(Node* root, int key) {
2 | if (key < root->key) {
3 | if (root->left == nullptr) {
4 | root->left = new Node(key);
5 | } else {
6 | insert_node(root->left, key);
7 | }
8 | } else {
9 | if (root->right == nullptr) {
10 | root->right = new Node(key);
11 | } else {
12 | insert_node(root->right, key);
13 | }
14 | }
15 | }
16 |
--------------------------------------------------------------------------------
/sprint5/By languages/C++/lesson8code1.cpp:
--------------------------------------------------------------------------------
1 | class Node {
2 | public:
3 | int key;
4 | int height;
5 | Node* left;
6 | Node* right;
7 |
8 | Node(int k, int h=1, Node* l=nullptr, Node* r=nullptr) : key(k), height(h), left(l), right(r) {}
9 | };
10 |
--------------------------------------------------------------------------------
/sprint5/By languages/C++/lesson8code3.cpp:
--------------------------------------------------------------------------------
1 | Node* big_left_rotation(Node* a) {
2 | Node* b = a->right;
3 | Node* c = b->left;
4 | Node* M = c->left;
5 | Node* N = c->right;
6 |
7 | a->right = M;
8 | b->left = N;
9 | c->left = a;
10 | c->right = b;
11 |
12 | a->height -= 2;
13 | b->height -= 1;
14 | c->height += 1;
15 | return c;
16 | }
17 |
--------------------------------------------------------------------------------
/sprint5/By languages/C++/lesson8code4.cpp:
--------------------------------------------------------------------------------
1 | Node* big_left_rotation(Node* v) {
2 | // Правым ребёнком становится новый корень правого поддерева.
3 | v->right = small_right_rotation(v->right);
4 | // Возвращаем новый корень поддерева.
5 | return small_left_rotation(v);
6 | }
7 |
--------------------------------------------------------------------------------
/sprint5/By languages/JS/lesson2code1.js:
--------------------------------------------------------------------------------
1 | class Node {
2 | constructor(obj, children = []) {
3 | this.obj = obj;
4 | this.children = children;
5 | }
6 | }
7 |
--------------------------------------------------------------------------------
/sprint5/By languages/JS/lesson2code2.js:
--------------------------------------------------------------------------------
1 | class Node {
2 | constructor(obj, left = null, right = null) {
3 | this.obj = obj;
4 | this.left = left;
5 | this.right = right;
6 | }
7 | }
8 |
--------------------------------------------------------------------------------
/sprint5/By languages/JS/lesson3code1.js:
--------------------------------------------------------------------------------
1 | function findNode(root, value) {
2 | if (root == null) {
3 | return null;
4 | }
5 | if (value < root.value) {
6 | return findNode(root.left, value);
7 | }
8 | if (value == root.value) {
9 | return root;
10 | }
11 | if (value > root.value) {
12 | return findNode(root.right, value);
13 | }
14 | }
15 |
--------------------------------------------------------------------------------
/sprint5/By languages/JS/lesson4code1.js:
--------------------------------------------------------------------------------
1 | function printForward(vertex) {
2 | console.log(vertex.value);
3 | vertex.children.forEach(child => printForward(child));
4 | }
5 |
--------------------------------------------------------------------------------
/sprint5/By languages/JS/lesson4code2.js:
--------------------------------------------------------------------------------
1 | function printReversed(vertex) {
2 | vertex.children.forEach(child => printReversed(child));
3 | console.log(vertex.value);
4 | }
5 |
--------------------------------------------------------------------------------
/sprint5/By languages/JS/lesson4code3.js:
--------------------------------------------------------------------------------
1 | function print_LMR(vertex) {
2 | if (vertex.left !== null) {
3 | print_LMR(vertex.left);
4 | }
5 | console.log(vertex.value);
6 | if (vertex.right !== null) {
7 | print_LMR(vertex.right);
8 | }
9 | }
10 |
--------------------------------------------------------------------------------
/sprint5/By languages/JS/lesson5code1.js:
--------------------------------------------------------------------------------
1 | function insert_node(root, key) {
2 | if (key < root.key) {
3 | if (root.left === null) {
4 | root.left = new Node(key);
5 | } else {
6 | insert_node(root.left, key);
7 | }
8 | } else {
9 | if (root.right === null) {
10 | root.right = new Node(key);
11 | } else {
12 | insert_node(root.right, key);
13 | }
14 | }
15 | }
16 |
--------------------------------------------------------------------------------
/sprint5/By languages/JS/lesson8code1.js:
--------------------------------------------------------------------------------
1 | class Node {
2 | constructor(k, h=1, l=null, r=null) {
3 | this.key = k;
4 | this.height = h;
5 | this.left = l;
6 | this.right = r;
7 | }
8 | }
9 |
--------------------------------------------------------------------------------
/sprint5/By languages/JS/lesson8code3.js:
--------------------------------------------------------------------------------
1 | function bigLeftRotation(a) {
2 | const b = a.right;
3 | const c = b.left;
4 | const M = c.left;
5 | const N = c.right;
6 |
7 | a.right = M;
8 | b.left = N;
9 | c.left = a;
10 | c.right = b;
11 |
12 | a.height -= 2;
13 | b.height -= 1;
14 | c.height += 1;
15 | return c;
16 | }
17 |
--------------------------------------------------------------------------------
/sprint5/By languages/JS/lesson8code4.js:
--------------------------------------------------------------------------------
1 | function bigLeftRotation(v) {
2 | // Правым ребёнком становится новый корень правого поддерева.
3 | v.right = smallRightRotation(v.right);
4 | // Возвращаем новый корень поддерева.
5 | return smallLeftRotation(v);
6 | }
7 |
--------------------------------------------------------------------------------
/sprint5/By languages/Java/lesson2code1.java:
--------------------------------------------------------------------------------
1 | import java.util.List;
2 |
3 | public class Node {
4 | public int obj;
5 | public List children;
6 |
7 | public Node(int obj, List children) {
8 | this.obj = obj;
9 | this.children = children;
10 | }
11 |
12 | public Node(int obj) {
13 | this(obj, null);
14 | }
15 | }
16 |
--------------------------------------------------------------------------------
/sprint5/By languages/Java/lesson2code2.java:
--------------------------------------------------------------------------------
1 | public class Node {
2 | public Node(int obj, Node left, Node right) {
3 | this.obj = obj;
4 | this.left = left;
5 | this.right = right;
6 | }
7 | public int obj;
8 | public Node left;
9 | public Node right;
10 | }
11 |
--------------------------------------------------------------------------------
/sprint5/By languages/Java/lesson3code1.java:
--------------------------------------------------------------------------------
1 | public Node findNode(Node root, int value) {
2 | if (root == null) {
3 | return null;
4 | }
5 | if (value < root.getValue()) {
6 | return findNode(root.getLeft(), value);
7 | }
8 | if (value == root.getValue()) {
9 | return root;
10 | }
11 | if (value > root.getValue()) {
12 | return findNode(root.getRight(), value);
13 | }
14 | }
15 |
--------------------------------------------------------------------------------
/sprint5/By languages/Java/lesson4code1.java:
--------------------------------------------------------------------------------
1 | void printForward(Node vertex) {
2 | System.out.println(vertex.value);
3 | for (Node child : vertex.children) {
4 | printForward(child);
5 | }
6 | }
7 |
--------------------------------------------------------------------------------
/sprint5/By languages/Java/lesson4code2.java:
--------------------------------------------------------------------------------
1 | void printReversed(Node vertex) {
2 | for (Node child : vertex.children) {
3 | printReversed(child);
4 | }
5 | System.out.println(vertex.value);
6 | }
7 |
--------------------------------------------------------------------------------
/sprint5/By languages/Java/lesson4code3.java:
--------------------------------------------------------------------------------
1 | void print_LMR(Node vertex) {
2 | if (vertex.left != null) {
3 | print_LMR(vertex.left);
4 | }
5 | System.out.println(vertex.value);
6 | if (vertex.right != null) {
7 | print_LMR(vertex.right);
8 | }
9 | }
10 |
--------------------------------------------------------------------------------
/sprint5/By languages/Java/lesson5code1.java:
--------------------------------------------------------------------------------
1 | void insert_node(Node root, int key) {
2 | if (key < root.key) {
3 | if (root.left == null) {
4 | root.left = new Node(key);
5 | } else {
6 | insert_node(root.left, key);
7 | }
8 | } else {
9 | if (root.right == null) {
10 | root.right = new Node(key);
11 | } else {
12 | insert_node(root.right, key);
13 | }
14 | }
15 | }
16 |
--------------------------------------------------------------------------------
/sprint5/By languages/Java/lesson8code1.java:
--------------------------------------------------------------------------------
1 | class Node {
2 | int key;
3 | int height;
4 | Node left;
5 | Node right;
6 |
7 | public Node(int k, int h, Node l, Node r) {
8 | key = k;
9 | height = h;
10 | left = l;
11 | right = r;
12 | }
13 |
14 | public Node(int k) {
15 | this(k, 1, null, null);
16 | }
17 | }
18 |
--------------------------------------------------------------------------------
/sprint5/By languages/Java/lesson8code3.java:
--------------------------------------------------------------------------------
1 | Node bigLeftRotation(Node a) {
2 | Node b = a.right;
3 | Node c = b.left;
4 | Node M = c.left;
5 | Node N = c.right;
6 |
7 | a.right = M;
8 | b.left = N;
9 | c.left = a;
10 | c.right = b;
11 |
12 | a.height -= 2;
13 | b.height -= 1;
14 | c.height += 1;
15 | return c;
16 | }
17 |
--------------------------------------------------------------------------------
/sprint5/By languages/Java/lesson8code4.java:
--------------------------------------------------------------------------------
1 | public Node bigLeftRotation(Node v) {
2 | // Правым ребёнком становится новый корень правого поддерева.
3 | v.right = smallRightRotation(v.right);
4 | // Возвращаем новый корень поддерева.
5 | return smallLeftRotation(v);
6 | }
7 |
--------------------------------------------------------------------------------
/sprint5/By languages/go/lesson2code1.go:
--------------------------------------------------------------------------------
1 | type Node struct {
2 | obj int
3 | children []*Node
4 | }
5 |
6 | func NewNode(obj int, children ...*Node) *Node {
7 | return &Node{obj: obj, children: children}
8 | }
9 |
--------------------------------------------------------------------------------
/sprint5/By languages/go/lesson2code2.go:
--------------------------------------------------------------------------------
1 | type Node struct {
2 | obj int
3 | left *Node
4 | right *Node
5 | }
6 |
7 | func NewNode(obj int, left, right *Node) *Node {
8 | return &Node{obj: obj, left: left, right: right}
9 | }
10 |
--------------------------------------------------------------------------------
/sprint5/By languages/go/lesson3code1.go:
--------------------------------------------------------------------------------
1 | func findNode(root *Node, value int) *Node {
2 | if root == nil {
3 | return nil
4 | }
5 | if value < root.value {
6 | return findNode(root.left, value)
7 | }
8 | if value == root.value {
9 | return root
10 | }
11 | if value > root.value {
12 | return findNode(root.right, value)
13 | }
14 | }
15 |
--------------------------------------------------------------------------------
/sprint5/By languages/go/lesson4code1.go:
--------------------------------------------------------------------------------
1 | func printForward(vertex *Node) {
2 | fmt.Println(vertex.value)
3 | for _, child := range vertex.children {
4 | printForward(child)
5 | }
6 | }
7 |
--------------------------------------------------------------------------------
/sprint5/By languages/go/lesson4code2.go:
--------------------------------------------------------------------------------
1 | func printReversed(vertex *Node) {
2 | for _, child := range vertex.children {
3 | printReversed(child)
4 | }
5 | fmt.Println(vertex.value)
6 | }
7 |
--------------------------------------------------------------------------------
/sprint5/By languages/go/lesson4code3.go:
--------------------------------------------------------------------------------
1 | func print_LMR(vertex *Node) {
2 | if vertex.left != nil {
3 | print_LMR(vertex.left)
4 | }
5 | fmt.Println(vertex.value)
6 | if vertex.right != nil {
7 | print_LMR(vertex.right)
8 | }
9 | }
10 |
--------------------------------------------------------------------------------
/sprint5/By languages/go/lesson5code1.go:
--------------------------------------------------------------------------------
1 | func insert_node(root *Node, key int) {
2 | if key < root.key {
3 | if root.left == nil {
4 | root.left = &Node{key: key}
5 | } else {
6 | insert_node(root.left, key)
7 | }
8 | } else {
9 | if root.right == nil {
10 | root.right = &Node{key: key}
11 | } else {
12 | insert_node(root.right, key)
13 | }
14 | }
15 | }
16 |
--------------------------------------------------------------------------------
/sprint5/By languages/go/lesson8code1.go:
--------------------------------------------------------------------------------
1 | type Node struct {
2 | key int
3 | height int
4 | left *Node
5 | right *Node
6 | }
7 |
8 | func NewNode(k int, h int, l *Node, r *Node) *Node {
9 | return &Node{key: k, height: h, left: l, right: r}
10 | }
11 |
12 | func NewNode(k int) *Node {
13 | return NewNode(k, 1, nil, nil)
14 | }
15 |
--------------------------------------------------------------------------------
/sprint5/By languages/go/lesson8code3.go:
--------------------------------------------------------------------------------
1 | func bigLeftRotation(a *Node) *Node {
2 | b := a.right
3 | c := b.left
4 | M := c.left
5 | N := c.right
6 |
7 | a.right = M
8 | b.left = N
9 | c.left = a
10 | c.right = b
11 |
12 | a.height -= 2
13 | b.height -= 1
14 | c.height += 1
15 | return c
16 | }
17 |
--------------------------------------------------------------------------------
/sprint5/By languages/go/lesson8code4.go:
--------------------------------------------------------------------------------
1 | func bigLeftRotation(v *Node) *Node {
2 | // Правым ребёнком становится новый корень правого поддерева.
3 | v.right = smallRightRotation(v.right);
4 | // Возвращаем новый корень поддерева.
5 | return smallLeftRotation(v);
6 | }
7 |
--------------------------------------------------------------------------------
/sprint5/By languages/kotlin/lesson12code1.kt:
--------------------------------------------------------------------------------
1 | fun calculateSizes(root: Node?): Int {
2 | // Базовый случай рекурсии – это пустое дерево из нуля вершин.
3 | if (root == null) {
4 | return 0
5 | }
6 | // Иначе суммируем размеры левого и правого поддерева
7 | // и прибавляем саму вершину root.
8 | root.size = 1 + calculateSizes(root.left) + calculateSizes(root.right)
9 | return root.size
10 | }
11 |
--------------------------------------------------------------------------------
/sprint5/By languages/kotlin/lesson2code1.kt:
--------------------------------------------------------------------------------
1 | class Node(var obj: Any, var children: MutableList = mutableListOf())
--------------------------------------------------------------------------------
/sprint5/By languages/kotlin/lesson2code2.kt:
--------------------------------------------------------------------------------
1 | class Node(var obj: Any, var left: Node? = null, var right: Node? = null)
--------------------------------------------------------------------------------
/sprint5/By languages/kotlin/lesson4code1.kt:
--------------------------------------------------------------------------------
1 | fun printForward(vertex: Vertex) {
2 | println(vertex.value)
3 | for (child in vertex.children) {
4 | printForward(child)
5 | }
6 | }
7 |
--------------------------------------------------------------------------------
/sprint5/By languages/kotlin/lesson4code2.kt:
--------------------------------------------------------------------------------
1 |
2 | fun printReversed(vertex: Vertex) {
3 | for (child in vertex.children) {
4 | printReversed(child)
5 | }
6 | println(vertex.value)
7 | }
8 |
9 |
--------------------------------------------------------------------------------
/sprint5/By languages/kotlin/lesson4code3.kt:
--------------------------------------------------------------------------------
1 | fun printLMR(vertex: Vertex) {
2 | if (vertex.left != null) {
3 | printLMR(vertex.left)
4 | }
5 | println(vertex.value)
6 | if (vertex.right != null) {
7 | printLMR(vertex.right)
8 | }
9 | }
10 |
--------------------------------------------------------------------------------
/sprint5/By languages/kotlin/lesson8code1.kt:
--------------------------------------------------------------------------------
1 | class Node {
2 | var key: Int
3 | var height: Int = 1
4 | var left: Node? = null
5 | var right: Node? = null
6 |
7 | constructor(key: Int, height: Int = 1, left: Node? = null, right: Node? = null) {
8 | this.key = key
9 | this.height = height
10 | this.left = left
11 | this.right = right
12 | }
13 | }
14 |
--------------------------------------------------------------------------------
/sprint5/By languages/kotlin/lesson8code4.kt:
--------------------------------------------------------------------------------
1 | fun bigLeftRotation(v: Node): Node {
2 | // Правым ребенком становится новый корень правого поддерева.
3 | v.right = smallRightRotation(v.right)
4 | // Возвращаем новый корень поддерева.
5 | return smallLeftRotation(v)
6 | }
7 |
--------------------------------------------------------------------------------
/sprint5/By languages/python/lesson2code1.py:
--------------------------------------------------------------------------------
1 | class Node:
2 | def __init__(self, obj, children=None):
3 | self.obj = obj
4 | if children is not None:
5 | self.children = children
6 | else:
7 | self.children = []
8 |
--------------------------------------------------------------------------------
/sprint5/By languages/python/lesson2code2.py:
--------------------------------------------------------------------------------
1 | class Node:
2 | def __init__(self, obj, left=None, right=None):
3 | self.obj = obj
4 | self.left = left
5 | self.right = right
--------------------------------------------------------------------------------
/sprint5/By languages/python/lesson3code1.py:
--------------------------------------------------------------------------------
1 | def find_node(root, value):
2 | # Если мы пришли в поддерево, а его не существует, значит, нужного элемента в дереве поиска нет
3 | if root is None:
4 | return f"Значение {value} не найдено"
5 | if value < root.value:
6 | return find_node(root.left, value)
7 | if value = root.value:
8 | return root
9 | if value > root.value:
10 | return find_node(root.right, value)
11 |
--------------------------------------------------------------------------------
/sprint5/By languages/python/lesson4code1.py:
--------------------------------------------------------------------------------
1 | def print_forward(vertex):
2 | print(vertex.value)
3 | for child in vertex.children:
4 | print_forward(child)
5 |
6 |
--------------------------------------------------------------------------------
/sprint5/By languages/python/lesson4code2.py:
--------------------------------------------------------------------------------
1 | def print_reversed(vertex):
2 | for child in vertex.children
3 | print_reversed(child)
4 | print(vertex.value)
--------------------------------------------------------------------------------
/sprint5/By languages/python/lesson4code3.py:
--------------------------------------------------------------------------------
1 | def print_LMR(vertex):
2 | if not vertex.left is None:
3 | print_LMR(vertex.left)
4 | print(vertex.value)
5 | if not vertex.right is None:
6 | return print_LMR(vertex.right)
--------------------------------------------------------------------------------
/sprint5/By languages/python/lesson5code1.py:
--------------------------------------------------------------------------------
1 | def insert_node(root, key):
2 | if key < root.key:
3 | if root.left is None:
4 | root.left = Node(key)
5 | else:
6 | insert_node(root.left, key)
7 | if key >= root.key:
8 | if root.right is None:
9 | root.right = Node(key)
10 | else:
11 | insert_node(root.right, key)
12 |
13 |
--------------------------------------------------------------------------------
/sprint5/By languages/python/lesson8code1.py:
--------------------------------------------------------------------------------
1 | class Node:
2 | def __init__(self, key, height=1, left=None, right=None):
3 | self.key = key
4 | self.left = left
5 | self.right = right
6 | self.height = height
7 |
--------------------------------------------------------------------------------
/sprint5/By languages/python/lesson8code3.py:
--------------------------------------------------------------------------------
1 | def big_left_rotation(a):
2 | # Задаём обозначения.
3 | b = a.right
4 | c = b.left
5 | M = c.left
6 | N = c.right
7 |
8 | # Переусыновляем вершины.
9 | a.right = M
10 | b.left = N
11 | c.left = a
12 | c.right = b
13 |
14 | # Корректируем высоты.
15 | a.height -= 2
16 | b.height -= 1
17 | c.height += 1
18 |
19 | # Возвращаем новый корень.
20 | return c
21 |
--------------------------------------------------------------------------------
/sprint5/By languages/python/lesson8code4.py:
--------------------------------------------------------------------------------
1 | def big_left_rotation(v):
2 | # Правым ребёнком становится новый корень правого поддерева.
3 | v.right = small_right_rotation(v.right)
4 | # Возвращаем новый корень поддерева.
5 | return small_left rotation(v)
6 |
--------------------------------------------------------------------------------
/sprint5/By languages/swift/lesson2code1.swift:
--------------------------------------------------------------------------------
1 | class Node {
2 | let obj: T
3 | var children: [Node]
4 |
5 | init(obj: T, children: [Node] = []) {
6 | self.obj = obj
7 | self.children = children
8 | }
9 | }
--------------------------------------------------------------------------------
/sprint5/By languages/swift/lesson2code2.swift:
--------------------------------------------------------------------------------
1 | class Node {
2 | let obj: T
3 | var left: Node?
4 | var right: Node?
5 |
6 | init(obj: T, left: Node? = nil, right: Node? = nil) {
7 | self.obj = obj
8 | self.left = left
9 | self.right = right
10 | }
11 | }
12 |
--------------------------------------------------------------------------------
/sprint5/By languages/swift/lesson4code1.swift:
--------------------------------------------------------------------------------
1 | func printForward(_ vertex: Node) {
2 | print(vertex.value)
3 | for child in vertex.children {
4 | printForward(child)
5 | }
6 | }
--------------------------------------------------------------------------------
/sprint5/By languages/swift/lesson4code2.swift:
--------------------------------------------------------------------------------
1 | func printReversed(_ vertex: Node) {
2 | for child in vertex.children {
3 | printReversed(child)
4 | }
5 | print(vertex.value)
6 | }
--------------------------------------------------------------------------------
/sprint5/By languages/swift/lesson4code3.swift:
--------------------------------------------------------------------------------
1 | func printLMR(_ vertex: Node?) {
2 | guard let vertex = vertex else {
3 | return
4 | }
5 |
6 | if let leftChild = vertex.left {
7 | printLMR(leftChild)
8 | }
9 |
10 | print(vertex.value)
11 |
12 | if let rightChild = vertex.right {
13 | printLMR(rightChild)
14 | }
15 | }
--------------------------------------------------------------------------------
/sprint5/By languages/swift/lesson8code1.swift:
--------------------------------------------------------------------------------
1 | class Node {
2 | var key: T
3 | var left: Node?
4 | var right: Node?
5 | var height: Int
6 |
7 | init(key: T, height: Int = 1, left: Node? = nil, right: Node? = nil) {
8 | self.key = key
9 | self.left = left
10 | self.right = right
11 | self.height = height
12 | }
13 | }
--------------------------------------------------------------------------------
/sprint5/By languages/swift/lesson8code4.swift:
--------------------------------------------------------------------------------
1 | func bigLeftRotation(_ v: Node) -> Node {
2 | // Правым ребёнком становится новый корень правого поддерева.
3 | let newRight = smallRightRotation(v.right)
4 | v.right = newRight
5 |
6 | // Возвращаем новый корень поддерева.
7 | return smallLeftRotation(v)
8 | }
9 |
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson12code1/lesson12code1.js:
--------------------------------------------------------------------------------
1 | function calculateSizes(root) {
2 | // Базовый случай рекурсии – это пустое дерево из нуля вершин.
3 | if (root === null) {
4 | return 0;
5 | }
6 | // Иначе суммируем размеры левого и правого поддерева
7 | // и прибавляем саму вершину root.
8 | root.size = 1 + calculateSizes(root.left) + calculateSizes(root.right);
9 | return root.size;
10 | }
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson12code1/lesson12code1.kt:
--------------------------------------------------------------------------------
1 | fun calculateSizes(root: Node?): Int {
2 | // Базовый случай рекурсии – это пустое дерево из нуля вершин.
3 | if (root == null) {
4 | return 0
5 | }
6 | // Иначе суммируем размеры левого и правого поддерева
7 | // и прибавляем саму вершину root.
8 | root.size = 1 + calculateSizes(root.left) + calculateSizes(root.right)
9 | return root.size
10 | }
11 |
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson12code1/lesson12code1.py:
--------------------------------------------------------------------------------
1 | def calculateSizes(root):
2 | # Базовый случай рекурсии – это пустое дерево из нуля вершин.
3 | if root is None:
4 | return 0
5 | # Иначе суммируем размеры левого и правого поддерева
6 | # и прибавляем саму вершину root.
7 | root.size = 1 + calculateSizes(root.left) + calculateSizes(root.right)
8 | return root.size
9 |
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson2code1/lesson2code1.cpp:
--------------------------------------------------------------------------------
1 | #include
2 |
3 | class Node {
4 | public:
5 | Node(int obj, std::vector children = {}): obj(obj), children(children) {}
6 | int obj;
7 | std::vector children;
8 | };
9 |
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson2code1/lesson2code1.cs:
--------------------------------------------------------------------------------
1 | using System.Collections.Generic;
2 |
3 | public class Node {
4 | public int Obj { get; set; }
5 | public List Children { get; set; }
6 |
7 | public Node(int obj, List children = null) {
8 | Obj = obj;
9 | Children = children ?? new List();
10 | }
11 | }
12 |
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson2code1/lesson2code1.go:
--------------------------------------------------------------------------------
1 | type Node struct {
2 | obj int
3 | children []*Node
4 | }
5 |
6 | func NewNode(obj int, children ...*Node) *Node {
7 | return &Node{obj: obj, children: children}
8 | }
9 |
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson2code1/lesson2code1.java:
--------------------------------------------------------------------------------
1 | import java.util.List;
2 |
3 | public class Node {
4 | public int obj;
5 | public List children;
6 |
7 | public Node(int obj, List children) {
8 | this.obj = obj;
9 | this.children = children;
10 | }
11 |
12 | public Node(int obj) {
13 | this(obj, null);
14 | }
15 | }
16 |
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson2code1/lesson2code1.js:
--------------------------------------------------------------------------------
1 | class Node {
2 | constructor(obj, children = []) {
3 | this.obj = obj;
4 | this.children = children;
5 | }
6 | }
7 |
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson2code1/lesson2code1.kt:
--------------------------------------------------------------------------------
1 | class Node(var obj: Any, var children: MutableList = mutableListOf())
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson2code1/lesson2code1.py:
--------------------------------------------------------------------------------
1 | class Node:
2 | def __init__(self, obj, children=None):
3 | self.obj = obj
4 | if children is not None:
5 | self.children = children
6 | else:
7 | self.children = []
8 |
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson2code1/lesson2code1.swift:
--------------------------------------------------------------------------------
1 | class Node {
2 | let obj: T
3 | var children: [Node]
4 |
5 | init(obj: T, children: [Node] = []) {
6 | self.obj = obj
7 | self.children = children
8 | }
9 | }
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson2code2/lesson2code2.cpp:
--------------------------------------------------------------------------------
1 | class Node {
2 | public:
3 | Node(int obj, Node* left = nullptr, Node* right = nullptr)
4 | : obj(obj), left(left), right(right) {}
5 | int obj;
6 | Node* left;
7 | Node* right;
8 | };
9 |
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson2code2/lesson2code2.cs:
--------------------------------------------------------------------------------
1 | public class Node {
2 | public Node(int obj, Node left = null, Node right = null) {
3 | this.obj = obj;
4 | this.left = left;
5 | this.right = right;
6 | }
7 | public int obj;
8 | public Node left;
9 | public Node right;
10 | }
11 |
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson2code2/lesson2code2.go:
--------------------------------------------------------------------------------
1 | type Node struct {
2 | obj int
3 | left *Node
4 | right *Node
5 | }
6 |
7 | func NewNode(obj int, left, right *Node) *Node {
8 | return &Node{obj: obj, left: left, right: right}
9 | }
10 |
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson2code2/lesson2code2.java:
--------------------------------------------------------------------------------
1 | public class Node {
2 | public Node(int obj, Node left, Node right) {
3 | this.obj = obj;
4 | this.left = left;
5 | this.right = right;
6 | }
7 | public int obj;
8 | public Node left;
9 | public Node right;
10 | }
11 |
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson2code2/lesson2code2.js:
--------------------------------------------------------------------------------
1 | class Node {
2 | constructor(obj, left = null, right = null) {
3 | this.obj = obj;
4 | this.left = left;
5 | this.right = right;
6 | }
7 | }
8 |
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson2code2/lesson2code2.kt:
--------------------------------------------------------------------------------
1 | class Node(var obj: Any, var left: Node? = null, var right: Node? = null)
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson2code2/lesson2code2.py:
--------------------------------------------------------------------------------
1 | class Node:
2 | def __init__(self, obj, left=None, right=None):
3 | self.obj = obj
4 | self.left = left
5 | self.right = right
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson2code2/lesson2code2.swift:
--------------------------------------------------------------------------------
1 | class Node {
2 | let obj: T
3 | var left: Node?
4 | var right: Node?
5 |
6 | init(obj: T, left: Node? = nil, right: Node? = nil) {
7 | self.obj = obj
8 | self.left = left
9 | self.right = right
10 | }
11 | }
12 |
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson3code1/lesson3code1.cpp:
--------------------------------------------------------------------------------
1 | Node* find_node(Node* root, int value) {
2 | if (root == nullptr) {
3 | return nullptr;
4 | }
5 | if (value < root->value) {
6 | return find_node(root->left, value);
7 | }
8 | if (value == root->value) {
9 | return root;
10 | }
11 | if (value > root->value) {
12 | return find_node(root->right, value);
13 | }
14 | }
15 |
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson3code1/lesson3code1.cs:
--------------------------------------------------------------------------------
1 | Node FindNode(Node root, int value) {
2 | if (root == null) {
3 | return null;
4 | }
5 | if (value < root.Value) {
6 | return FindNode(root.Left, value);
7 | }
8 | if (value == root.Value) {
9 | return root;
10 | }
11 | if (value > root.Value) {
12 | return FindNode(root.Right, value);
13 | }
14 | }
15 |
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson3code1/lesson3code1.go:
--------------------------------------------------------------------------------
1 | func findNode(root *Node, value int) *Node {
2 | if root == nil {
3 | return nil
4 | }
5 | if value < root.value {
6 | return findNode(root.left, value)
7 | }
8 | if value == root.value {
9 | return root
10 | }
11 | if value > root.value {
12 | return findNode(root.right, value)
13 | }
14 | }
15 |
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson3code1/lesson3code1.java:
--------------------------------------------------------------------------------
1 | public Node findNode(Node root, int value) {
2 | if (root == null) {
3 | return null;
4 | }
5 | if (value < root.getValue()) {
6 | return findNode(root.getLeft(), value);
7 | }
8 | if (value == root.getValue()) {
9 | return root;
10 | }
11 | if (value > root.getValue()) {
12 | return findNode(root.getRight(), value);
13 | }
14 | }
15 |
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson3code1/lesson3code1.js:
--------------------------------------------------------------------------------
1 | function findNode(root, value) {
2 | if (root == null) {
3 | return null;
4 | }
5 | if (value < root.value) {
6 | return findNode(root.left, value);
7 | }
8 | if (value == root.value) {
9 | return root;
10 | }
11 | if (value > root.value) {
12 | return findNode(root.right, value);
13 | }
14 | }
15 |
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson3code1/lesson3code1.py:
--------------------------------------------------------------------------------
1 | def find_node(root, value):
2 | # Если мы пришли в поддерево, а его не существует, значит, нужного элемента в дереве поиска нет
3 | if root is None:
4 | return f"Значение {value} не найдено"
5 | if value < root.value:
6 | return find_node(root.left, value)
7 | if value = root.value:
8 | return root
9 | if value > root.value:
10 | return find_node(root.right, value)
11 |
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson4code1/lesson4code1.cpp:
--------------------------------------------------------------------------------
1 | void print_forward(Node* vertex) {
2 | std::cout << vertex->value << std::endl;
3 | for (Node* child : vertex->children) {
4 | print_forward(child);
5 | }
6 | }
7 |
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson4code1/lesson4code1.cs:
--------------------------------------------------------------------------------
1 | void PrintForward(Node vertex) {
2 | Console.WriteLine(vertex.Value);
3 | foreach (Node child in vertex.Children) {
4 | PrintForward(child);
5 | }
6 | }
7 |
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson4code1/lesson4code1.go:
--------------------------------------------------------------------------------
1 | func printForward(vertex *Node) {
2 | fmt.Println(vertex.value)
3 | for _, child := range vertex.children {
4 | printForward(child)
5 | }
6 | }
7 |
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson4code1/lesson4code1.java:
--------------------------------------------------------------------------------
1 | void printForward(Node vertex) {
2 | System.out.println(vertex.value);
3 | for (Node child : vertex.children) {
4 | printForward(child);
5 | }
6 | }
7 |
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson4code1/lesson4code1.js:
--------------------------------------------------------------------------------
1 | function printForward(vertex) {
2 | console.log(vertex.value);
3 | vertex.children.forEach(child => printForward(child));
4 | }
5 |
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson4code1/lesson4code1.kt:
--------------------------------------------------------------------------------
1 | fun printForward(vertex: Vertex) {
2 | println(vertex.value)
3 | for (child in vertex.children) {
4 | printForward(child)
5 | }
6 | }
7 |
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson4code1/lesson4code1.py:
--------------------------------------------------------------------------------
1 | def print_forward(vertex):
2 | print(vertex.value)
3 | for child in vertex.children:
4 | print_forward(child)
5 |
6 |
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson4code1/lesson4code1.swift:
--------------------------------------------------------------------------------
1 | func printForward(_ vertex: Node) {
2 | print(vertex.value)
3 | for child in vertex.children {
4 | printForward(child)
5 | }
6 | }
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson4code2/lesson4code2.cpp:
--------------------------------------------------------------------------------
1 | void print_reversed(Node* vertex) {
2 | for (auto child : vertex->children) {
3 | print_reversed(child);
4 | }
5 | std::cout << vertex->value << std::endl;
6 | }
7 |
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson4code2/lesson4code2.cs:
--------------------------------------------------------------------------------
1 | void PrintReversed(Node vertex) {
2 | foreach (var child in vertex.children) {
3 | PrintReversed(child);
4 | }
5 | Console.WriteLine(vertex.value);
6 | }
7 |
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson4code2/lesson4code2.go:
--------------------------------------------------------------------------------
1 | func printReversed(vertex *Node) {
2 | for _, child := range vertex.children {
3 | printReversed(child)
4 | }
5 | fmt.Println(vertex.value)
6 | }
7 |
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson4code2/lesson4code2.java:
--------------------------------------------------------------------------------
1 | void printReversed(Node vertex) {
2 | for (Node child : vertex.children) {
3 | printReversed(child);
4 | }
5 | System.out.println(vertex.value);
6 | }
7 |
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson4code2/lesson4code2.js:
--------------------------------------------------------------------------------
1 | function printReversed(vertex) {
2 | vertex.children.forEach(child => printReversed(child));
3 | console.log(vertex.value);
4 | }
5 |
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson4code2/lesson4code2.kt:
--------------------------------------------------------------------------------
1 |
2 | fun printReversed(vertex: Vertex) {
3 | for (child in vertex.children) {
4 | printReversed(child)
5 | }
6 | println(vertex.value)
7 | }
8 |
9 |
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson4code2/lesson4code2.py:
--------------------------------------------------------------------------------
1 | def print_reversed(vertex):
2 | for child in vertex.children
3 | print_reversed(child)
4 | print(vertex.value)
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson4code2/lesson4code2.swift:
--------------------------------------------------------------------------------
1 | func printReversed(_ vertex: Node) {
2 | for child in vertex.children {
3 | printReversed(child)
4 | }
5 | print(vertex.value)
6 | }
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson4code3/lesson4code3.cpp:
--------------------------------------------------------------------------------
1 | void print_LMR(Node* vertex) {
2 | if (vertex->left != nullptr) {
3 | print_LMR(vertex->left);
4 | }
5 | std::cout << vertex->value << std::endl;
6 | if (vertex->right != nullptr) {
7 | print_LMR(vertex->right);
8 | }
9 | }
10 |
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson4code3/lesson4code3.cs:
--------------------------------------------------------------------------------
1 | void print_LMR(Node vertex) {
2 | if (vertex.left != null) {
3 | print_LMR(vertex.left);
4 | }
5 | Console.WriteLine(vertex.value);
6 | if (vertex.right != null) {
7 | print_LMR(vertex.right);
8 | }
9 | }
10 |
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson4code3/lesson4code3.go:
--------------------------------------------------------------------------------
1 | func print_LMR(vertex *Node) {
2 | if vertex.left != nil {
3 | print_LMR(vertex.left)
4 | }
5 | fmt.Println(vertex.value)
6 | if vertex.right != nil {
7 | print_LMR(vertex.right)
8 | }
9 | }
10 |
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson4code3/lesson4code3.java:
--------------------------------------------------------------------------------
1 | void print_LMR(Node vertex) {
2 | if (vertex.left != null) {
3 | print_LMR(vertex.left);
4 | }
5 | System.out.println(vertex.value);
6 | if (vertex.right != null) {
7 | print_LMR(vertex.right);
8 | }
9 | }
10 |
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson4code3/lesson4code3.js:
--------------------------------------------------------------------------------
1 | function print_LMR(vertex) {
2 | if (vertex.left !== null) {
3 | print_LMR(vertex.left);
4 | }
5 | console.log(vertex.value);
6 | if (vertex.right !== null) {
7 | print_LMR(vertex.right);
8 | }
9 | }
10 |
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson4code3/lesson4code3.kt:
--------------------------------------------------------------------------------
1 | fun printLMR(vertex: Vertex) {
2 | if (vertex.left != null) {
3 | printLMR(vertex.left)
4 | }
5 | println(vertex.value)
6 | if (vertex.right != null) {
7 | printLMR(vertex.right)
8 | }
9 | }
10 |
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson4code3/lesson4code3.py:
--------------------------------------------------------------------------------
1 | def print_LMR(vertex):
2 | if not vertex.left is None:
3 | print_LMR(vertex.left)
4 | print(vertex.value)
5 | if not vertex.right is None:
6 | return print_LMR(vertex.right)
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson4code3/lesson4code3.swift:
--------------------------------------------------------------------------------
1 | func printLMR(_ vertex: Node?) {
2 | guard let vertex = vertex else {
3 | return
4 | }
5 |
6 | if let leftChild = vertex.left {
7 | printLMR(leftChild)
8 | }
9 |
10 | print(vertex.value)
11 |
12 | if let rightChild = vertex.right {
13 | printLMR(rightChild)
14 | }
15 | }
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson5code1/lesson5code1.cpp:
--------------------------------------------------------------------------------
1 | void insert_node(Node* root, int key) {
2 | if (key < root->key) {
3 | if (root->left == nullptr) {
4 | root->left = new Node(key);
5 | } else {
6 | insert_node(root->left, key);
7 | }
8 | } else {
9 | if (root->right == nullptr) {
10 | root->right = new Node(key);
11 | } else {
12 | insert_node(root->right, key);
13 | }
14 | }
15 | }
16 |
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson5code1/lesson5code1.cs:
--------------------------------------------------------------------------------
1 | void insert_node(Node root, int key) {
2 | if (key < root.key) {
3 | if (root.left == null) {
4 | root.left = new Node(key);
5 | } else {
6 | insert_node(root.left, key);
7 | }
8 | } else {
9 | if (root.right == null) {
10 | root.right = new Node(key);
11 | } else {
12 | insert_node(root.right, key);
13 | }
14 | }
15 | }
16 |
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson5code1/lesson5code1.go:
--------------------------------------------------------------------------------
1 | func insert_node(root *Node, key int) {
2 | if key < root.key {
3 | if root.left == nil {
4 | root.left = &Node{key: key}
5 | } else {
6 | insert_node(root.left, key)
7 | }
8 | } else {
9 | if root.right == nil {
10 | root.right = &Node{key: key}
11 | } else {
12 | insert_node(root.right, key)
13 | }
14 | }
15 | }
16 |
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson5code1/lesson5code1.java:
--------------------------------------------------------------------------------
1 | void insert_node(Node root, int key) {
2 | if (key < root.key) {
3 | if (root.left == null) {
4 | root.left = new Node(key);
5 | } else {
6 | insert_node(root.left, key);
7 | }
8 | } else {
9 | if (root.right == null) {
10 | root.right = new Node(key);
11 | } else {
12 | insert_node(root.right, key);
13 | }
14 | }
15 | }
16 |
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson5code1/lesson5code1.js:
--------------------------------------------------------------------------------
1 | function insert_node(root, key) {
2 | if (key < root.key) {
3 | if (root.left === null) {
4 | root.left = new Node(key);
5 | } else {
6 | insert_node(root.left, key);
7 | }
8 | } else {
9 | if (root.right === null) {
10 | root.right = new Node(key);
11 | } else {
12 | insert_node(root.right, key);
13 | }
14 | }
15 | }
16 |
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson5code1/lesson5code1.py:
--------------------------------------------------------------------------------
1 | def insert_node(root, key):
2 | if key < root.key:
3 | if root.left is None:
4 | root.left = Node(key)
5 | else:
6 | insert_node(root.left, key)
7 | if key >= root.key:
8 | if root.right is None:
9 | root.right = Node(key)
10 | else:
11 | insert_node(root.right, key)
12 |
13 |
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson8code1/lesson8code1.cpp:
--------------------------------------------------------------------------------
1 | class Node {
2 | public:
3 | int key;
4 | int height;
5 | Node* left;
6 | Node* right;
7 |
8 | Node(int k, int h=1, Node* l=nullptr, Node* r=nullptr) : key(k), height(h), left(l), right(r) {}
9 | };
10 |
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson8code1/lesson8code1.cs:
--------------------------------------------------------------------------------
1 | class Node {
2 | public int key;
3 | public int height;
4 | public Node left;
5 | public Node right;
6 |
7 | public Node(int k, int h=1, Node l=null, Node r=null) {
8 | key = k;
9 | height = h;
10 | left = l;
11 | right = r;
12 | }
13 | }
14 |
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson8code1/lesson8code1.go:
--------------------------------------------------------------------------------
1 | type Node struct {
2 | key int
3 | height int
4 | left *Node
5 | right *Node
6 | }
7 |
8 | func NewNode(k int, h int, l *Node, r *Node) *Node {
9 | return &Node{key: k, height: h, left: l, right: r}
10 | }
11 |
12 | func NewNode(k int) *Node {
13 | return NewNode(k, 1, nil, nil)
14 | }
15 |
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson8code1/lesson8code1.java:
--------------------------------------------------------------------------------
1 | class Node {
2 | int key;
3 | int height;
4 | Node left;
5 | Node right;
6 |
7 | public Node(int k, int h, Node l, Node r) {
8 | key = k;
9 | height = h;
10 | left = l;
11 | right = r;
12 | }
13 |
14 | public Node(int k) {
15 | this(k, 1, null, null);
16 | }
17 | }
18 |
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson8code1/lesson8code1.js:
--------------------------------------------------------------------------------
1 | class Node {
2 | constructor(k, h=1, l=null, r=null) {
3 | this.key = k;
4 | this.height = h;
5 | this.left = l;
6 | this.right = r;
7 | }
8 | }
9 |
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson8code1/lesson8code1.kt:
--------------------------------------------------------------------------------
1 | class Node {
2 | var key: Int
3 | var height: Int = 1
4 | var left: Node? = null
5 | var right: Node? = null
6 |
7 | constructor(key: Int, height: Int = 1, left: Node? = null, right: Node? = null) {
8 | this.key = key
9 | this.height = height
10 | this.left = left
11 | this.right = right
12 | }
13 | }
14 |
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson8code1/lesson8code1.py:
--------------------------------------------------------------------------------
1 | class Node:
2 | def __init__(self, key, height=1, left=None, right=None):
3 | self.key = key
4 | self.left = left
5 | self.right = right
6 | self.height = height
7 |
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson8code1/lesson8code1.swift:
--------------------------------------------------------------------------------
1 | class Node {
2 | var key: T
3 | var left: Node?
4 | var right: Node?
5 | var height: Int
6 |
7 | init(key: T, height: Int = 1, left: Node? = nil, right: Node? = nil) {
8 | self.key = key
9 | self.left = left
10 | self.right = right
11 | self.height = height
12 | }
13 | }
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson8code3/lesson8code3.cpp:
--------------------------------------------------------------------------------
1 | Node* big_left_rotation(Node* a) {
2 | Node* b = a->right;
3 | Node* c = b->left;
4 | Node* M = c->left;
5 | Node* N = c->right;
6 |
7 | a->right = M;
8 | b->left = N;
9 | c->left = a;
10 | c->right = b;
11 |
12 | a->height -= 2;
13 | b->height -= 1;
14 | c->height += 1;
15 | return c;
16 | }
17 |
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson8code3/lesson8code3.cs:
--------------------------------------------------------------------------------
1 | Node BigLeftRotation(Node a) {
2 | Node b = a.right;
3 | Node c = b.left;
4 | Node M = c.left;
5 | Node N = c.right;
6 |
7 | a.right = M;
8 | b.left = N;
9 | c.left = a;
10 | c.right = b;
11 |
12 | a.height -= 2;
13 | b.height -= 1;
14 | c.height += 1;
15 | return c;
16 | }
17 |
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson8code3/lesson8code3.go:
--------------------------------------------------------------------------------
1 | func bigLeftRotation(a *Node) *Node {
2 | b := a.right
3 | c := b.left
4 | M := c.left
5 | N := c.right
6 |
7 | a.right = M
8 | b.left = N
9 | c.left = a
10 | c.right = b
11 |
12 | a.height -= 2
13 | b.height -= 1
14 | c.height += 1
15 | return c
16 | }
17 |
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson8code3/lesson8code3.java:
--------------------------------------------------------------------------------
1 | Node bigLeftRotation(Node a) {
2 | Node b = a.right;
3 | Node c = b.left;
4 | Node M = c.left;
5 | Node N = c.right;
6 |
7 | a.right = M;
8 | b.left = N;
9 | c.left = a;
10 | c.right = b;
11 |
12 | a.height -= 2;
13 | b.height -= 1;
14 | c.height += 1;
15 | return c;
16 | }
17 |
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson8code3/lesson8code3.js:
--------------------------------------------------------------------------------
1 | function bigLeftRotation(a) {
2 | const b = a.right;
3 | const c = b.left;
4 | const M = c.left;
5 | const N = c.right;
6 |
7 | a.right = M;
8 | b.left = N;
9 | c.left = a;
10 | c.right = b;
11 |
12 | a.height -= 2;
13 | b.height -= 1;
14 | c.height += 1;
15 | return c;
16 | }
17 |
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson8code3/lesson8code3.py:
--------------------------------------------------------------------------------
1 | def big_left_rotation(a):
2 | # Задаём обозначения.
3 | b = a.right
4 | c = b.left
5 | M = c.left
6 | N = c.right
7 |
8 | # Переусыновляем вершины.
9 | a.right = M
10 | b.left = N
11 | c.left = a
12 | c.right = b
13 |
14 | # Корректируем высоты.
15 | a.height -= 2
16 | b.height -= 1
17 | c.height += 1
18 |
19 | # Возвращаем новый корень.
20 | return c
21 |
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson8code4/lesson8code4.cpp:
--------------------------------------------------------------------------------
1 | Node* big_left_rotation(Node* v) {
2 | // Правым ребёнком становится новый корень правого поддерева.
3 | v->right = small_right_rotation(v->right);
4 | // Возвращаем новый корень поддерева.
5 | return small_left_rotation(v);
6 | }
7 |
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson8code4/lesson8code4.cs:
--------------------------------------------------------------------------------
1 | Node BigLeftRotation(Node v) {
2 | // Правым ребёнком становится новый корень правого поддерева.
3 | v.right = SmallRightRotation(v.right);
4 | // Возвращаем новый корень поддерева.
5 | return SmallLeftRotation(v);
6 | }
7 |
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson8code4/lesson8code4.go:
--------------------------------------------------------------------------------
1 | func bigLeftRotation(v *Node) *Node {
2 | // Правым ребёнком становится новый корень правого поддерева.
3 | v.right = smallRightRotation(v.right);
4 | // Возвращаем новый корень поддерева.
5 | return smallLeftRotation(v);
6 | }
7 |
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson8code4/lesson8code4.java:
--------------------------------------------------------------------------------
1 | public Node bigLeftRotation(Node v) {
2 | // Правым ребёнком становится новый корень правого поддерева.
3 | v.right = smallRightRotation(v.right);
4 | // Возвращаем новый корень поддерева.
5 | return smallLeftRotation(v);
6 | }
7 |
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson8code4/lesson8code4.js:
--------------------------------------------------------------------------------
1 | function bigLeftRotation(v) {
2 | // Правым ребёнком становится новый корень правого поддерева.
3 | v.right = smallRightRotation(v.right);
4 | // Возвращаем новый корень поддерева.
5 | return smallLeftRotation(v);
6 | }
7 |
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson8code4/lesson8code4.kt:
--------------------------------------------------------------------------------
1 | fun bigLeftRotation(v: Node): Node {
2 | // Правым ребенком становится новый корень правого поддерева.
3 | v.right = smallRightRotation(v.right)
4 | // Возвращаем новый корень поддерева.
5 | return smallLeftRotation(v)
6 | }
7 |
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson8code4/lesson8code4.py:
--------------------------------------------------------------------------------
1 | def big_left_rotation(v):
2 | # Правым ребёнком становится новый корень правого поддерева.
3 | v.right = small_right_rotation(v.right)
4 | # Возвращаем новый корень поддерева.
5 | return small_left rotation(v)
6 |
--------------------------------------------------------------------------------
/sprint5/By lessons/lesson8code4/lesson8code4.swift:
--------------------------------------------------------------------------------
1 | func bigLeftRotation(_ v: Node) -> Node {
2 | // Правым ребёнком становится новый корень правого поддерева.
3 | let newRight = smallRightRotation(v.right)
4 | v.right = newRight
5 |
6 | // Возвращаем новый корень поддерева.
7 | return smallLeftRotation(v)
8 | }
9 |
--------------------------------------------------------------------------------
/sprint6/By languages/C#/lesson4code1.cs:
--------------------------------------------------------------------------------
1 | void PrintReversed(Node node) {
2 | foreach (Node child in node.Children) {
3 | PrintReversed(child);
4 | }
5 | Console.WriteLine(node.Value);
6 | }
7 |
--------------------------------------------------------------------------------
/sprint6/By languages/C++/lesson4code1.cpp:
--------------------------------------------------------------------------------
1 | void printReversed(Node* node) {
2 | for (Node* child : node->children) {
3 | printReversed(child);
4 | }
5 | std::cout << node->value << std::endl;
6 | }
7 |
--------------------------------------------------------------------------------
/sprint6/By languages/JS/lesson4code1.js:
--------------------------------------------------------------------------------
1 | function printReversed(node) {
2 | for (let child of node.children) {
3 | printReversed(child);
4 | }
5 | console.log(node.value);
6 | }
7 |
--------------------------------------------------------------------------------
/sprint6/By languages/Java/lesson4code1.java:
--------------------------------------------------------------------------------
1 | void printReversed(Node node) {
2 | for (Node child : node.getChildren()) {
3 | printReversed(child);
4 | }
5 | System.out.println(node.getValue());
6 | }
7 |
--------------------------------------------------------------------------------
/sprint6/By languages/go/lesson4code1.go:
--------------------------------------------------------------------------------
1 | func printReversed(node *Node) {
2 | for _, child := range node.children {
3 | printReversed(child)
4 | }
5 | fmt.Println(node.value)
6 | }
7 |
--------------------------------------------------------------------------------
/sprint6/By languages/kotlin/lesson4code1.kt:
--------------------------------------------------------------------------------
1 | fun printReversed(node: Node) {
2 | for (child in node.children) {
3 | printReversed(child)
4 | }
5 | println(node.value)
6 | }
7 |
--------------------------------------------------------------------------------
/sprint6/By languages/swift/lesson4code1.swift:
--------------------------------------------------------------------------------
1 | func printReversed(node: Node) {
2 | for child in node.children {
3 | printReversed(node: child)
4 | }
5 | print(node.value)
6 | }
7 |
--------------------------------------------------------------------------------
/sprint6/By lessons/lesson4code1/lesson4code1.cpp:
--------------------------------------------------------------------------------
1 | void printReversed(Node* node) {
2 | for (Node* child : node->children) {
3 | printReversed(child);
4 | }
5 | std::cout << node->value << std::endl;
6 | }
7 |
--------------------------------------------------------------------------------
/sprint6/By lessons/lesson4code1/lesson4code1.cs:
--------------------------------------------------------------------------------
1 | void PrintReversed(Node node) {
2 | foreach (Node child in node.Children) {
3 | PrintReversed(child);
4 | }
5 | Console.WriteLine(node.Value);
6 | }
7 |
--------------------------------------------------------------------------------
/sprint6/By lessons/lesson4code1/lesson4code1.go:
--------------------------------------------------------------------------------
1 | func printReversed(node *Node) {
2 | for _, child := range node.children {
3 | printReversed(child)
4 | }
5 | fmt.Println(node.value)
6 | }
7 |
--------------------------------------------------------------------------------
/sprint6/By lessons/lesson4code1/lesson4code1.java:
--------------------------------------------------------------------------------
1 | void printReversed(Node node) {
2 | for (Node child : node.getChildren()) {
3 | printReversed(child);
4 | }
5 | System.out.println(node.getValue());
6 | }
7 |
--------------------------------------------------------------------------------
/sprint6/By lessons/lesson4code1/lesson4code1.js:
--------------------------------------------------------------------------------
1 | function printReversed(node) {
2 | for (let child of node.children) {
3 | printReversed(child);
4 | }
5 | console.log(node.value);
6 | }
7 |
--------------------------------------------------------------------------------
/sprint6/By lessons/lesson4code1/lesson4code1.kt:
--------------------------------------------------------------------------------
1 | fun printReversed(node: Node) {
2 | for (child in node.children) {
3 | printReversed(child)
4 | }
5 | println(node.value)
6 | }
7 |
--------------------------------------------------------------------------------
/sprint6/By lessons/lesson4code1/lesson4code1.swift:
--------------------------------------------------------------------------------
1 | func printReversed(node: Node) {
2 | for child in node.children {
3 | printReversed(node: child)
4 | }
5 | print(node.value)
6 | }
7 |
--------------------------------------------------------------------------------
/sprint7/By languages/kotlin/lesson9code3.kt:
--------------------------------------------------------------------------------
1 | val dp = Array(n + 1) { Array(m + 1) { 0 } }
2 | for (i in 1..n) {
3 | var maxVal = 0
4 | for (j in 1..m) {
5 | dp[i][j] = dp[i - 1][j]
6 | if (A[i - 1] == B[j - 1]) {
7 | dp[i][j] = maxOf(dp[i][j], maxVal + 1)
8 | }
9 | if (B[j - 1] < A[i - 1]) {
10 | maxVal = maxOf(maxVal, dp[i - 1][j])
11 | }
12 | }
13 | }
14 |
--------------------------------------------------------------------------------
/sprint7/By languages/python/lesson9code3.py:
--------------------------------------------------------------------------------
1 | dp = [[0] for i in range(n + 1)] for j in range(m + 1)]
2 | for i in range(1, n + 1):
3 | max_val = 0
4 | for j in range(1, m + 1):
5 | dp[i][j] = dp[i - 1][j]
6 | if A[i - 1] == B[j - 1]:
7 | dp[i][j] = max(dp[i][j], max_val + 1)
8 | if B[j - 1] < A[i - 1]:
9 | max_val = max(max_val, dp[i - 1][j])
--------------------------------------------------------------------------------
/sprint7/By lessons/lesson9code3/lesson9code3.kt:
--------------------------------------------------------------------------------
1 | val dp = Array(n + 1) { Array(m + 1) { 0 } }
2 | for (i in 1..n) {
3 | var maxVal = 0
4 | for (j in 1..m) {
5 | dp[i][j] = dp[i - 1][j]
6 | if (A[i - 1] == B[j - 1]) {
7 | dp[i][j] = maxOf(dp[i][j], maxVal + 1)
8 | }
9 | if (B[j - 1] < A[i - 1]) {
10 | maxVal = maxOf(maxVal, dp[i - 1][j])
11 | }
12 | }
13 | }
14 |
--------------------------------------------------------------------------------
/sprint7/By lessons/lesson9code3/lesson9code3.py:
--------------------------------------------------------------------------------
1 | dp = [[0] for i in range(n + 1)] for j in range(m + 1)]
2 | for i in range(1, n + 1):
3 | max_val = 0
4 | for j in range(1, m + 1):
5 | dp[i][j] = dp[i - 1][j]
6 | if A[i - 1] == B[j - 1]:
7 | dp[i][j] = max(dp[i][j], max_val + 1)
8 | if B[j - 1] < A[i - 1]:
9 | max_val = max(max_val, dp[i - 1][j])
--------------------------------------------------------------------------------
/sprint8/By languages/C#/lesson2code1.cs:
--------------------------------------------------------------------------------
1 | bool Compare(string first, string second) {
2 | if (first.Length != second.Length) {
3 | return false;
4 | }
5 |
6 | int length = first.Length;
7 | for (int i = 0; i < length; ++i) {
8 | if (first[i] != second[i]) {
9 | return false;
10 | }
11 | }
12 |
13 | return true;
14 | }
15 |
--------------------------------------------------------------------------------
/sprint8/By languages/C++/lesson2code1.cpp:
--------------------------------------------------------------------------------
1 | bool compare(const std::string& first, const std::string& second) {
2 | if (first.length() != second.length()) {
3 | return false;
4 | }
5 |
6 | size_t length = first.length();
7 | for (size_t i = 0; i < length; ++i) {
8 | if (first[i] != second[i]) {
9 | return false;
10 | }
11 | }
12 |
13 | return true;
14 | }
15 |
--------------------------------------------------------------------------------
/sprint8/By languages/C++/lesson6code1.cpp:
--------------------------------------------------------------------------------
1 | int N = s.length();
2 | vector π(N, 0);
3 |
4 | for (int i = 1; i < N; i++) {
5 | string substring = s.substr(0, i);
6 | for (int k = i - 1; k >= 0; k--) {
7 | string prefix = substring.substr(0, k);
8 | string suffix = substring.substr(i - k, i);
9 | if (prefix == suffix) {
10 | π[i-1] = k;
11 | break;
12 | }
13 | }
14 | }
15 |
--------------------------------------------------------------------------------
/sprint8/By languages/C++/lesson6code2.cpp:
--------------------------------------------------------------------------------
1 | vector prefix_function(string s) {
2 | int N = s.length();
3 | vector π(N, 0);
4 | for (int i = 1; i < N; i++) {
5 | int k = π[i - 1];
6 | while (k > 0 && s[k] != s[i]) {
7 | k = π[k - 1];
8 | }
9 | if (s[k] == s[i]) {
10 | k += 1;
11 | }
12 | π[i] = k;
13 | }
14 | return π;
15 | }
16 |
--------------------------------------------------------------------------------
/sprint8/By languages/JS/lesson2code1.js:
--------------------------------------------------------------------------------
1 | function compare(first, second) {
2 | if (first.length !== second.length) {
3 | return false;
4 | }
5 |
6 | var length = first.length;
7 | for (var i = 0; i < length; ++i) {
8 | if (first[i] !== second[i]) {
9 | return false;
10 | }
11 | }
12 |
13 | return true;
14 | }
15 |
--------------------------------------------------------------------------------
/sprint8/By languages/JS/lesson6code1.js:
--------------------------------------------------------------------------------
1 | const N = s.length;
2 | const π = new Array(N).fill(0);
3 |
4 | for (let i = 1; i < N; i++) {
5 | const substring = s.slice(0, i);
6 | for (let k = i - 1; k >= 0; k--) {
7 | const prefix = substring.slice(0, k);
8 | const suffix = substring.slice(i - k, i);
9 | if (prefix === suffix) {
10 | π[i - 1] = k;
11 | break;
12 | }
13 | }
14 | }
15 |
--------------------------------------------------------------------------------
/sprint8/By languages/JS/lesson6code2.js:
--------------------------------------------------------------------------------
1 | function prefix_function(s) {
2 | const N = s.length;
3 | const π = new Array(N);
4 | π[0] = 0;
5 |
6 | for (let i = 1; i < N; i++) {
7 | let k = π[i - 1];
8 | while (k > 0 && s.charAt(k) !== s.charAt(i)) {
9 | k = π[k - 1];
10 | }
11 | if (s.charAt(k) === s.charAt(i)) {
12 | k++;
13 | }
14 | π[i] = k;
15 | }
16 | return π;
17 | }
18 |
--------------------------------------------------------------------------------
/sprint8/By languages/Java/lesson2code1.java:
--------------------------------------------------------------------------------
1 | boolean compare(String first, String second) {
2 | if (first.length() != second.length()) {
3 | return false;
4 | }
5 |
6 | int length = first.length();
7 | for (int i = 0; i < length; ++i) {
8 | if (first.charAt(i) != second.charAt(i)) {
9 | return false;
10 | }
11 | }
12 |
13 | return true;
14 | }
15 |
--------------------------------------------------------------------------------
/sprint8/By languages/go/lesson2code1.go:
--------------------------------------------------------------------------------
1 | func compare(first, second string) bool {
2 | if len(first) != len(second) {
3 | return false
4 | }
5 |
6 | length := len(first)
7 | for i := 0; i < length; i++ {
8 | if first[i] != second[i] {
9 | return false
10 | }
11 | }
12 |
13 | return true
14 | }
15 |
--------------------------------------------------------------------------------
/sprint8/By languages/go/lesson4code2.go:
--------------------------------------------------------------------------------
1 | func findAll(text string, pattern string) []int {
2 | occurrences := []int{}
3 | start := 0
4 | for {
5 | pos := find(text, pattern, start)
6 | if pos == -1 {
7 | break
8 | }
9 | occurrences = append(occurrences, pos)
10 | start = pos + 1
11 | }
12 | return occurrences
13 | }
14 |
--------------------------------------------------------------------------------
/sprint8/By languages/go/lesson6code2.go:
--------------------------------------------------------------------------------
1 | func prefixFunction(s string) []int {
2 | // Функция возвращает массив длины |s|
3 | π := make([]int, len(s))
4 | for i := 1; i < len(s); i++ {
5 | k := π[i-1]
6 | for k > 0 && s[k] != s[i] {
7 | k = π[k-1]
8 | }
9 | if s[k] == s[i] {
10 | k++
11 | }
12 | π[i] = k
13 | }
14 | return π
15 | }
16 |
--------------------------------------------------------------------------------
/sprint8/By languages/kotlin/lesson2code1.kt:
--------------------------------------------------------------------------------
1 | fun compare(first: String, second: String): Boolean {
2 | if (first.length != second.length) {
3 | return false
4 | }
5 |
6 | val length = first.length
7 | for (i in 0 until length) {
8 | if (first[i] != second[i]) {
9 | return false
10 | }
11 | }
12 |
13 | return true
14 | }
15 |
--------------------------------------------------------------------------------
/sprint8/By languages/python/lesson2code1.py:
--------------------------------------------------------------------------------
1 | def compare(first, second):
2 | if len(first) != len(second):
3 | return False
4 |
5 | length = len(first)
6 | for i in range(length):
7 | if first[i] != second[i]:
8 | return False
9 |
10 | return True
11 |
--------------------------------------------------------------------------------
/sprint8/By languages/swift/lesson2code1.swift:
--------------------------------------------------------------------------------
1 | func compare(first: [Character], second: [Character]) -> Bool {
2 | if first.count != second.count {
3 | return false
4 | }
5 |
6 | let length = first.count
7 | for i in 0.. Bool {
2 | if first.count != second.count {
3 | return false
4 | }
5 |
6 | let length = first.count
7 | for i in 0..= 0; k--) {
7 | const prefix = substring.slice(0, k);
8 | const suffix = substring.slice(i - k, i);
9 | if (prefix === suffix) {
10 | π[i - 1] = k;
11 | break;
12 | }
13 | }
14 | }
15 |
--------------------------------------------------------------------------------
/sprint8/By lessons/lesson6code2/lesson6code2.cpp:
--------------------------------------------------------------------------------
1 | vector prefix_function(string s) {
2 | int N = s.length();
3 | vector π(N, 0);
4 | for (int i = 1; i < N; i++) {
5 | int k = π[i - 1];
6 | while (k > 0 && s[k] != s[i]) {
7 | k = π[k - 1];
8 | }
9 | if (s[k] == s[i]) {
10 | k += 1;
11 | }
12 | π[i] = k;
13 | }
14 | return π;
15 | }
16 |
--------------------------------------------------------------------------------
/sprint8/By lessons/lesson6code2/lesson6code2.go:
--------------------------------------------------------------------------------
1 | func prefixFunction(s string) []int {
2 | // Функция возвращает массив длины |s|
3 | π := make([]int, len(s))
4 | for i := 1; i < len(s); i++ {
5 | k := π[i-1]
6 | for k > 0 && s[k] != s[i] {
7 | k = π[k-1]
8 | }
9 | if s[k] == s[i] {
10 | k++
11 | }
12 | π[i] = k
13 | }
14 | return π
15 | }
16 |
--------------------------------------------------------------------------------
/sprint8/By lessons/lesson6code2/lesson6code2.js:
--------------------------------------------------------------------------------
1 | function prefix_function(s) {
2 | const N = s.length;
3 | const π = new Array(N);
4 | π[0] = 0;
5 |
6 | for (let i = 1; i < N; i++) {
7 | let k = π[i - 1];
8 | while (k > 0 && s.charAt(k) !== s.charAt(i)) {
9 | k = π[k - 1];
10 | }
11 | if (s.charAt(k) === s.charAt(i)) {
12 | k++;
13 | }
14 | π[i] = k;
15 | }
16 | return π;
17 | }
18 |
--------------------------------------------------------------------------------