Move Lesson #2: Basic Types and Exercise to Documentation

In this commit, the data related to Lesson #2: Basic Types and the exercise has been removed from the current file and relocated to the documentation. The content has been organized into separate folders, 'lessons' and 'exercises', for better structuring and clarity. This ensures that the main file remains clean and concise, while the detailed information can be found in the respective documentation folders. This modification enhances the maintainability and organization of the project.'

Author: ArtemZarubin

documentation/official-kotlin-documentation/exercises/2-Variable-declaration/VariableDeclaration.md

@@ -0,0 +1,38 @@
+# Exercise: Variable declaration
+
+## Instructions
+
+Explicitly declare the correct type for each variable:
+
+```kotlin
+fun main() {
+ val a = 1000
+ val b = "log message"
+ val c = 3.14
+ val d = 100_000_000_000_000
+ val e = false
+ val f = '\n'
+}
+```
+## Solution
+```kotlin
+fun main() {
+ val a: Int = 1000
+ val b: String = "log message"
+ val c: Double = 3.14
+ val d: Long = 100_000_000_000
+ val e: Boolean = false
+ val f: Char = '\n'
+}
+```
+The code represents the declaration of variables with explicitly specified types and assignment of corresponding values. Here's an explanation of the code execution:
+
+- Variable **a** is declared with the type **Int** and assigned the value **1000**.
+- Variable **b** is declared with the type **String** and assigned the value "**log message**".
+- Variable **c** is declared with the type **Double** and assigned the value **3.14**.
+- Variable **d** is declared with the type **Long** and assigned the value **100_000_000_000**. Note that the underscore character is used in the number for improved readability.
+- Variable **e** is declared with the type **Boolean** and assigned the value false.
+- Variable **f** is declared with the type **Char** and assigned the value '**\n**', which represents the newline character.
+As a result of executing this code, all variables will be declared with explicitly specified types and their corresponding values. This provides the compiler with information about the data types that can be used and supported for each variable.
+
+Good luck!

documentation/official-kotlin-documentation/lessons/2-Basic-types/BasicTypes.md

@@ -0,0 +1,52 @@
+# Lesson 2: Basic Types and Variable Declarations
+In Kotlin, every variable and data structure has a data type, which is important for determining the operations that can be performed on them. Kotlin supports type inference, where the compiler can automatically infer the data type based on the assigned value.
+
+## Basic Types
+Kotlin provides several basic types for different kinds of data:
+
+- Integers: **Byte**, **Short**, **Int**, **Long**
+- Unsigned Integers: **UByte**, **UShort**, **UInt**, **ULong**
+- Floating-point Numbers: **Float**, **Double**
+- Booleans: **Boolean**
+- Characters: **Char**
+- Strings: **String**
+For more detailed information about basic types and their properties, refer to the [Kotlin documentation on Basic Types](https://kotlinlang.org/docs/basic-types.html).
+
+## Variable Declarations
+Variables can be declared and initialized in Kotlin. If a variable is declared without initialization, its type must be specified using the **:** operator.
+
+```kotlin
+// Variable declared without initialization
+val d: Int
+// Variable initialized
+d = 3
+
+// Variable explicitly typed and initialized
+val e: String = "hello"
+```
+Variables must be initialized before the first read, but Kotlin allows for initialization at a later stage.
+
+## Augmented Assignment Operators
+Kotlin provides augmented assignment operators (**+=**, **-=**, ***=**, **/=**, **%=**) for performing arithmetic operations and updating the variable in-place.
+
+```kotlin
+var players = 5
+
+// Some players leave the game
+players = 3
+
+players = players + 1 // Example of addition: 4
+players += 5 // Example of addition: 9
+players -= 2 // Example of subtraction: 7
+players *= 3 // Example of multiplication: 21
+players /= 7 // Example of division: 3
+```
+## Variable Usage
+Variables can be used in string interpolation using the **$** symbol:
+
+```kotlin
+println("Number of players: $players") // Number of players: 3
+println("Integer: $woInit") // Integer: 7620
+println("My name is $myNameIs") // My name is Artem Zarubin
+```
+Now you have a basic understanding of basic types, variable declarations, and augmented assignment operators in Kotlin!

src/main/kotlin/Main.kt

@@ -1,38 +1,4 @@
 fun main(args: Array<String>) {
- // Lesson #2. Basic types
- var players = 5
-
- // Some players leave the game
- players = 3
-
- players = players + 1 // Example of addition: 4
- players += 5 // Example of addition: 9
- players -= 2 // Example of subtraction: 7
- players *= 3 // Example of multiplication: 21
- players /= 7 // Example of division: 3
-
- println("Number of players: $players") // Number of players: 3
-
- // Variable declared without initialization
- val woInit: Int
- // Variable initialized
- woInit = 7620 // My favorite number
-
- // Variable explicitly typed and initialized
- val myNameIs: String = "Artem Zarubin"
-
- // Variables can be read because they have been initialized
- println("Integer: $woInit") // Integer: 7620
- println("My name is $myNameIs") // My name is Artem Zarubin
-
- val aa: Int = 1000 // Exercise #2. Explicitly declare the correct type for each variable.
- val bb: String = "log message"
- val cc: Double = 3.14
- val dd: Long = 100_000_000_000_000
- val ee: Boolean = false
- val ff: Char = '\n'
- println()
-
  // Lesson #3. Collections
  // Read only list
  val readOnlyShapes = listOf("Circle", "Triangle", "Square")