Added code for funny number guessing game on Main.kt and new lessons 😄

Added code to the Main.kt file that implements a cool number guessing game. The code allows the user to input the range of numbers, generates a random number within that range, and prompts the user to guess the generated number. The user is given a limited number of attempts to guess the number correctly. The code also calculates the user's score based on the range difficulty and the number of remaining attempts. Additionally, included 8 new lessons and associated images. 🎉

Author: ArtemZarubin

documentation/jetBrains-academy/Kotlin-core/lessons/18-Reading-data-with-a-readln/ReadlnData.md

@@ -0,0 +1,168 @@
+# Reading data with readln
+
+In this topic, you will learn how to read information from user input and interact with it. You'll explore how to manage variables using the `readln()` function and work with different data types.
+
+## Standard input
+
+Standard input is a stream of data that goes into a program. It is supported by the operating system and, by default, obtains data from the keyboard. However, it is also possible to get input from a file.
+
+Although not all programs require standard input, you'll frequently encounter situations where it's needed. The typical approach to solving programming problems involves:
+
+1. Reading data from standard input.
+2. Processing the data to obtain a result.
+3. Outputting the result to standard output.
+
+Before writing programs that perform useful tasks, it's important to understand how to read data from standard input.
+
+## Using readln
+
+In Kotlin, you can use the `readln()` function to read data from standard input. This function reads the entire line as a string:
+
+```kotlin
+val line = readln()
+```
+The variable line has the type String because readln() returns a value of that type.
+
+In older versions of Kotlin, you may need to use readLine()!! instead of readln(). These functions do the same thing, but readln() is shorter and preferred. If you're using Kotlin 1.6 or higher, use readln().
+
+```kotlin
+val line = readLine()!! // before Kotlin 1.6
+```
+Note the exclamation marks. This construction ensures non-empty input to the compiler. We'll discuss it in more detail later.
+
+Here's a simple program that reads a line from standard input and outputs it to standard output:
+
+```kotlin
+fun main() {
+val line = readln()
+println(line)
+}
+```
+For example, if the input is "Hello, Kotlin", the output will be the same:
+
+```yaml
+Hello, Kotlin
+```
+By default, you need to press Enter to see the input information.
+
+Now, let's explore how to read different types of data using **readln()**.
+
+## toInt() and toLong()
+Sometimes you need to read numeric data from the user, such as their age or graduation year. To work with numeric values, you can use the **toInt()** function. To convert the input to an integer, use the **toInt()** function with dot syntax:
+
+```kotlin
+println("Enter any number: ")
+val number = readln().toInt()
+print("You entered the number: ")
+print(number)
+```
+For example, if the input is "56", the output will be:
+
+```csharp
+Enter any number:
+56
+You entered the number: 56
+```
+If you need to process larger numbers, like the cost of a luxury yacht, you can use the **toLong()** function:
+
+```kotlin
+println("How much is your yacht worth?")
+val cost = readln().toLong()
+print("You entered: ")
+print(cost)
+```
+For example, if the input is "10000000000", the output will be:
+
+```csharp
+How much is your yacht worth?
+10000000000
+You entered: 10000000000
+```
+## toDouble() and toBoolean()
+What if you need more precise values? For example, if you need to know the exact price of a liter of gasoline. In this case, you can't use **toInt()** or **toLong()** because the value might not be a whole number. Instead, you can use the **toDouble()** function:
+
+```kotlin
+println("Enter any double type number:")
+val number = readln().toDouble()
+println("You entered the number: ")
+print(number)
+```
+For example, if the input is "0.5673421", the output will be:
+
+```arduino
+Enter any double type number:
+0.5673421
+You entered the number: 0.5673421
+```
+The same logic applies to Boolean values. You can use the **toBoolean()** function:
+
+```kotlin
+println("The earth is flat. Type true or false:")
+val answer = readln().toBoolean()
+print("The earth is flat: ")
+print(answer)
+```
+For example, if the input is "false", the output will be:
+
+```csharp
+The earth is flat. Type true or false:
+false
+The earth is flat: false
+```
+## Multiple inputs
+Is it possible to receive and process multiple inputs? Yes, it is. You can declare multiple variables and assign them the value of the **readln()** function. If you want to enter several values with different data types, you need to press Enter to separate them.
+
+Here's an example that demonstrates multiple inputs and outputs:
+
+```kotlin
+val a = readln()
+val b = readln().toInt()
+val c = readln()
+print(a)
+print(" ")
+print(b)
+print(" ")
+print(c)
+```
+For example, if the inputs are "You earned", "100", and "points!", the output will be:
+
+```yaml
+You earned 100 points!
+```
+As you can see, handling multiple values of different data types is straightforward. You just need to declare multiple variables, assign them the desired **readln()** function, and display them correctly in the console.
+
+## Reading multiple values in one line
+If you need to read two values on the same line, you can use the following construction:
+
+```kotlin
+val (a, b) = readln().split(" ")
+println(a)
+println(b)
+```
+For example, if the input is "Hello, Kotlin", the output will be:
+
+```yaml
+Hello,
+Kotlin
+```
+This construction splits the input string at spaces and stores the words in the variables **a** and **b**. We'll discuss this in more detail later.
+
+Similarly, you can read up to four values per line:
+
+```kotlin
+val (a, b, c, d) = readln().split(" ")
+println(a)
+println(b)
+println(c)
+println(d)
+```
+For example, if the input is "Have a nice Kotlin", the output will be:
+
+```yaml
+Have
+a
+nice
+Kotlin
+```
+## Conclusion
+As you can see, reading input is straightforward in Kotlin. All you need to do is declare a variable with the value of the **readln()** function. The **readln()** function automatically converts the input to a **String** type. Your program can handle string, number, and boolean input by using type conversion with functions such as **toInt()**, **toLong()**, **toDouble()**, and **toBoolean()**. You can also handle multiple values of the same or different types.

documentation/jetBrains-academy/Kotlin-core/lessons/19-String-basics/StringBasics.md

@@ -0,0 +1,88 @@
+# String Basics
+In this lesson, we will explore the basics of working with strings in Kotlin. Strings are a fundamental data type in Kotlin and are used to represent sequences of characters. Understanding string operations and manipulations is essential for various programming tasks. Let's dive into the important concepts related to strings.
+
+## The Length of a String
+To determine the length of a string, you can use the **.length** property. It returns the number of characters in the string. Here's an example:
+
+```kotlin
+val language = "Kotlin"
+println(language.length) // Output: 6
+
+val empty = ""
+println(empty.length) // Output: 0
+```
+In the above example, **language.length** returns **6** since the string "**Kotlin**" consists of six characters. Similarly, **empty.length** returns **0** as the empty string has no characters.
+
+## Concatenating Strings
+Concatenation is the process of combining two or more strings into a single string. In Kotlin, you can use the **+** operator to concatenate strings. Here's an example:
+
+```kotlin
+val str1 = "ab"
+val str2 = "cde"
+val result = str1 + str2 // Output: "abcde"
+```
+In the above example, the strings "**ab**" and "**cde**" are concatenated using the **+** operator, resulting in the string "**abcde**".
+
+You can also concatenate multiple strings in the same expression:
+
+```kotlin
+val firstName = "John"
+val lastName = "Smith"
+val fullName = firstName + " " + lastName
+```
+In the above example, the strings "**John**", **" "**, and "**Smith**" are concatenated to form the full name "**John Smith**".
+
+## Appending Values to Strings
+You can append values of different types to a string using the **+** operator. The values are automatically converted to strings and then concatenated to the target string. Here's an example:
+
+```kotlin
+val stringPlusBoolean = "abc" + 10 + true
+println(stringPlusBoolean) // Output: abc10true
+
+val code = "123" + 456 + "789"
+println(code) // Output: 123456789
+```
+In the above example, the integer **10** and the boolean value true are appended to the string "**abc**". Similarly, the integer **456** is appended between the strings "**123**" and "**789**".
+
+It's important to note that the concatenation operation is not commutative. The order of concatenation matters. For example:
+
+```kotlin
+val one = "1"
+val two = "2"
+val twelve = one + two
+println(twelve) // Output: 12
+```
+In the above example, **one** + **two** concatenates the strings in the order they appear, resulting in the string "**12**".
+
+## Repeating the String
+![To do](https://github.com/ArtemZarubin/kotlin-lessons/blob/master/src/main/images/todo.png)
+
+If you need to repeat a string multiple times, you can use the **repeat()** function. It takes an integer argument specifying the number of repetitions. Here's an example:
+
+```kotlin
+print("Hello".repeat(4)) // Output: HelloHelloHelloHello
+```
+In the above example, the string "**Hello**" is repeated four times using the **repeat()** function, resulting in the output "**HelloHelloHelloHello**".
+
+## Raw String
+In some cases, you may need to include special characters like tabs or quotes in a string. To make it easier to write such strings, Kotlin provides raw strings. Raw strings can contain newlines and any other characters without the need for escape sequences. To define a raw string, enclose the text in triple quotes (**"""**). Here's an example:
+
+```kotlin
+val largeString = """
+This is the house that Jack built.
+
+ This is the malt that lay in the house that Jack built.
+ 
+ This is the rat that ate the malt
+ That lay in the house that Jack built.
+ 
+ This is the cat
+ That killed the rat that ate the malt
+ That lay in the house that Jack built.
+""".trimIndent()
+print(largeString)
+```
+In the above example, the raw string contains multiple lines and preserves the indentation. The **trimIndent()** function is used to remove the common minimal indent and trim the leading and trailing empty lines.
+
+## Conclusion
+In this lesson, we covered the basic operations and concepts related to strings in Kotlin. You learned about finding the length of a string, concatenating strings, appending values, repeating strings, and using raw strings. These foundational string operations are essential for manipulating and working with text in your Kotlin programs. Keep practicing and exploring the vast possibilities that strings offer in your programming journey. Good luck!

documentation/jetBrains-academy/Kotlin-core/lessons/20-String-templates/StringTemplates.md

@@ -0,0 +1,49 @@
+# String Templates
+In this lesson, we will explore string templates in Kotlin. String templates provide a convenient way to include variable values and expressions within strings. Let's dive into their purpose and usage.
+
+## Introduction to String Templates
+String templates allow us to insert variable values into a string and build dynamic messages or texts. Instead of manually concatenating strings and variables, we can use string templates to achieve the same result in a more readable and concise manner.
+
+## Basic Variable Interpolation
+To include the value of a variable within a string, we can use the dollar sign **$** followed by the variable name. The variable's value will be automatically inserted into the string. Here's an example:
+
+```kotlin
+val city = "Paris"
+val temp = "24"
+
+println("Now, the temperature in $city is $temp degrees Celsius.")
+```
+In the above example, the values of the variables **city** and **temp** are interpolated within the string using string templates. The resulting string is: "Now, the temperature in Paris is 24 degrees Celsius."
+
+Using string templates makes the code more readable and eliminates the need for explicit string concatenation.
+
+## Expressions in String Templates
+String templates also allow us to include the result of arbitrary expressions within a string. To do this, enclose the expression within curly braces **{}** after the dollar sign **$**. Here's an example:
+
+```kotlin
+val language = "Kotlin"
+println("$language has ${language.length} letters in the name")
+```
+In the above example, we use the expression **${language.length}** within the string template to retrieve the length of the **language** variable and include it in the string. The resulting output is: "Kotlin has 6 letters in the name."
+
+By using curly braces, we can evaluate any expression and include its result in the string template.
+
+## Idioms: String Interpolation
+Idioms are established patterns or practices that enhance the clarity and readability of code. String interpolation is an idiom in Kotlin that encourages the use of string templates for variable interpolation. It is considered a best practice in Kotlin coding style. Here's an example:
+
+```kotlin
+val language = "Kotlin"
+println("Have a nice $language!") // Good practice
+println("Have a nice " + language + "!") // Less preferred
+```
+In the above example, the first line uses string interpolation with the **variable** language directly embedded within the string using **$language**. This is the preferred and idiomatic way to achieve string interpolation in Kotlin. The second line demonstrates the less preferred method of string concatenation using the **+** operator.
+
+## Conclusion
+In this lesson, we covered string templates in Kotlin. We learned how to interpolate variable values within strings using the dollar sign **$** and include expressions within curly braces **{}** in string templates. We also discussed the idiom of string interpolation and its benefits for writing clear and readable code.
+
+Remember the following key points:
+
+1. Use string templates to insert variable values into a string: "**This string has $value**".
+2. Use curly braces for expressions in string templates: "The length is **${str.length}**".
+
+By utilizing string templates effectively, you can create dynamic and expressive strings in your Kotlin code.

documentation/jetBrains-academy/Kotlin-core/lessons/21-Boolean-and-logical-operations/BooleanVariables.md

@@ -0,0 +1,65 @@
+# Boolean and Logical Operations
+In this lesson, we will explore boolean values and logical operations in Kotlin. Booleans are fundamental data types that represent two opposite states: true and false. We will learn how to work with boolean variables and utilize logical operators to construct logical statements.
+
+## Boolean Variables
+Boolean variables in Kotlin can hold one of two values: true or false. Here's an example:
+
+![Foreign friend](https://github.com/ArtemZarubin/kotlin-lessons/blob/master/src/main/images/true-and-false.svg)
+
+```kotlin
+val t = true // t is true
+val f = false // f is false
+
+println(t) // true
+println(f) // false
+```
+Note that you cannot assign an integer value to a boolean variable. In Kotlin, 0 is not equivalent to false.
+
+## Reading Boolean Values
+In Kotlin 1.4 and later versions, you can read a boolean value from user input using **readLine().toBoolean()**. For Kotlin 1.6 and newer, you can use **readln().toBoolean()**.
+
+```kotlin
+val b: Boolean = readLine().toBoolean()
+
+// Example input:
+// true
+// Output:
+// true
+```
+The **toBoolean()** function converts the user input to a boolean value. If the input is "true" (case-insensitive), it returns true. Otherwise, it returns false.
+
+## Logical Operators
+Kotlin provides four logical operators for working with boolean values:
+
+**NOT**: Reverses the boolean value. Denoted by the **!** operator.
+**AND**: Returns true if both operands are true. Denoted by the **&&** operator.
+**OR**: Returns true if at least one operand is true. Denoted by the **||** operator.
+**XOR** (Exclusive OR): Returns true if the operands have different values. Denoted by the **xor** operator.
+Here are examples illustrating the usage of logical operators:
+
+```kotlin
+val f = false // f is false
+val t = !f // t is true (NOT operator)
+
+val b1 = false && false // false (AND operator)
+val b2 = false || true // true (OR operator)
+val b3 = true xor false // true (XOR operator)
+```
+The logical operators allow you to combine boolean values and create complex logical expressions.
+
+## Logical Operator Precedence
+Logical operators in Kotlin have a specific order of precedence. Here's the precedence from highest to lowest:
+
+- **!** (NOT)
+- **xor** (XOR)
+- **&&** (AND)
+- **|** (OR)
+Parentheses can be used to change the order of execution. For example:
+
+```kotlin
+val bool = true && !false // true (NOT is evaluated first)
+```
+By understanding the operator precedence, you can control the grouping of variables in logical expressions.
+
+## Conclusion
+In this lesson, we explored boolean values and logical operations in Kotlin. We learned about boolean variables, logical operators (NOT, XOR, AND, OR), and the precedence of logical operations. Understanding these concepts is essential for mastering Kotlin programming. Logical operations are powerful tools for making decisions and controlling program flow based on boolean conditions. Practice and experimentation will further solidify your understanding. Now, let's move on to solving some tasks to reinforce your knowledge.