Lesson 5

Welcome to the newest chapter of our journey through **Scala**: arithmetic and logical operations. These operations are the cornerstone of programming, facilitating calculations and decision-making. Let's dive right in!

Arithmetic operations in Scala include addition (`+`

), subtraction (`-`

), multiplication (`*`

), division (`/`

), and modulus (`%`

). The modulus operation, `%`

, calculates the remainder after dividing one number by another. For instance, `7 % 3`

equals `1`

, because 7 divided by 3 leaves a remainder of 1. We'll explore these operations through examples using variables `a`

and `b`

:

Scala`1@main def run: Unit = 2 val a = 10 3 val b = 2 4 5 println(a + b) // prints: 12 6 println(a - b) // prints: 8 7 println(a * b) // prints: 20 8 println(a / b) // prints: 5 9 println(a % b) // prints 0, because the remainder of 10/2 is 0`

Scala offers a means to streamline arithmetic operations combined with assignment through the use of compound assignment operators. These operators, which include `+=`

, `-=`

, `*=`

, `/=`

, and `%=`

, combine an arithmetic operation with an assignment to enhance code readability.

Scala`1@main def run: Unit = 2 var score = 100 3 score += 10 // same as `score = score + 10`, score is now 110 4 score -= 20 // same as `score = score - 20`, score is now 90 5 score *= 2 // same as `score = score * 2`, score is now 180 6 score /= 3 // same as `score = score / 3`, score is now 60 7 score %= 7 // same as `score = score % 7`, score is now 4`

Logical operations, specifically AND (`&&`

), OR (`||`

), and NOT (`!`

), are indispensable for making branching decisions in Scala. AND (`&&`

) returns `true`

only if both operands are true. OR (`||`

) returns `true`

if either operand is true. NOT (`!`

) inverts the boolean value. Here is an example of an in-game task:

Scala`1@main def run: Unit = 2 val hasEnoughPoints = true 3 val hasEnoughCoins = false 4 5 println(hasEnoughPoints && hasEnoughCoins) // prints: false 6 println(hasEnoughPoints || hasEnoughCoins) // prints: true 7 println(!hasEnoughCoins) // prints: true`

Arithmetic and logical operations can be combined. By using such combinations, let's illustrate the conditions for a game:

Scala`1@main def run: Unit = 2 val points = 150 3 val coins = 5 4 val isPremiumMember = true 5 6 val canUnlockLevel = points > 100 && (coins > 10 || isPremiumMember) 7 println(canUnlockLevel) // prints: true`

The expression `points > 100 && (coins > 10 || isPremiumMember)`

evaluates as follows: `points > 100`

returns `true`

because `points`

(150) is greater than 100, and inside the parentheses, `coins > 10`

returns `false`

because `coins`

(5) is not greater than 10, but `isPremiumMember`

is `true`

. With the `||`

operator, the overall expression inside the parentheses is `true`

, resulting in `true && true`

, which makes `canUnlockLevel`

evaluate to `true`

.

Congratulations on becoming familiar with arithmetic and logical operations in Scala! You have mastered how to shape our programs and influence behavior based on specific conditions using these operations. This newly-acquired knowledge will be reinforced with some practice exercises. Are you ready? Let's get started!