✨ (concepts) Add concept exercise interest-is-interesting

This is inspired by the same on csharp track. Provides introduction to while loops & floating point numbers.

Author: devkabiir

config.json

@@ -35,6 +35,21 @@
   },
   "exercises": {
     "concept": [
+      {
+        "slug": "interest-is-interesting",
+        "uuid": "8a81dfe7-e941-4f94-895d-2f2b8305153d",
+        "name": "Interest is Interesting",
+        "difficulty": 1,
+        "concepts": [
+          "floating-point-numbers",
+          "while-loops"
+        ],
+        "prerequisites": [
+          "assignment",
+          "if-statements"
+        ],
+        "status": "wip"
+      },
       {
         "slug": "lucians-luscious-lasagna",
         "uuid": "29a2d3bd-eec8-454d-9dba-4b2d7d071925",

exercises/concept/interest-is-interesting/.docs/hints.md

@@ -0,0 +1,42 @@
+# Hints
+
+## General
+
+- [Floating-point types][floating-point-types] section on Chapter 3.2 Data Types
+  of the Rust Book.
+
+## 1. Calculate the interest rate
+
+- By default, any floating-point number defined in Rust code is treated as a
+  [`f64`][f64].
+- To use [`f32`][f32] one can write numbers with a suffix of `_f32` or explicitly add
+  the type to declaration.
+  ```rust
+    let x = 2.0_f32;
+
+    let y: f32 = 3.0;
+  ```
+- [If statements][if-statements] can be used to return different values based on certain
+  conditions.
+
+
+## 2. Calculate the interest
+
+- When calculating interest, it might be helpful to notice that `interest_rate` returns a percentage.
+
+## 3. Calculate the annual balance update
+
+- When calculating the annual balance update, we can use methods we have defined in previous steps.
+
+## 4. Calculate the years before reaching the desired balance
+
+- To calculate the years, one can keep looping until the desired balance is
+  reached. You can use the [while-loop].
+
+[while-loop]: https://doc.rust-lang.org/rust-by-example/flow_control/while.html
+[f32]: https://doc.rust-lang.org/std/primitive.f32.html
+[f64]: https://doc.rust-lang.org/std/primitive.f64.html
+[if-statements]: https://doc.rust-lang.org/book/ch03-05-control-flow.html#if-expressions
+[floating-point-types]:
+    https://doc.rust-lang.org/book/ch03-02-data-types.html?highlight=floating#floating-point-types
+[rust-book]: https://doc.rust-lang.org/book

exercises/concept/interest-is-interesting/.docs/instructions.md

@@ -0,0 +1,59 @@
+# Instructions
+
+In this exercise you'll be working with savings accounts. Each year, the balance of your savings account is updated based on its interest rate.
+The interest rate your bank gives you depends on the amount of money in your account (its balance):
+
+- 3.213% for a negative balance (balance gets more negative).
+- 0.5% for a positive balance less than `1000` dollars.
+- 1.621% for a positive balance greater than or equal to `1000` dollars and less than `5000` dollars.
+- 2.475% for a positive balance greater than or equal to `5000` dollars.
+
+You have four tasks, each of which will deal your balance and its interest rate.
+
+## 1. Calculate the interest rate
+
+Implement the `interest_rate()` method to calculate the interest rate based on the specified balance:
+
+```rust
+interest_rate(200.75)
+// 0.5
+```
+
+
+## 2. Calculate the interest
+
+Implement the `interest()` method to calculate the interest based on the specified balance:
+
+```rust
+interest(200.75)
+// 1.00375
+```
+
+
+## 3. Calculate the annual balance update
+
+Implement the `annual_balance_update()` method to calculate the annual balance update, taking into account the interest rate:
+
+```rust
+annual_balance_update(200.75)
+// 201.75375
+```
+
+
+## 4. Calculate the years before reaching the desired balance
+
+Implement the `years_before_desired_balance()` method to calculate the minimum number of years required to reach the desired balance given annually compounding interest:
+
+```rust
+years_before_desired_balance(200.75, 214.88)
+// 14
+```
+
+Note that the value returned is an integer.
+
+~~~~exercism/note
+When applying simple interest to a principal balance, the balance is multiplied by the interest rate and the product of the two is the interest amount.
+
+Compound interest on the other hand is done by applying interest on a recurring basis.
+On each application the interest amount is computed and added to the principal balance so that subsequent interest calculations are subject to a greater principal balance.
+~~~~

exercises/concept/interest-is-interesting/.docs/introduction.md

@@ -0,0 +1,45 @@
+# Introduction
+
+## Floating Point Numbers
+
+A floating-point number is a number with zero or more digits behind the decimal
+separator.
+Examples are `-2.4`, `0.1`, `3.14`, `16.984025` and `1024.0`.
+
+Different floating-point types can store different numbers of digits after the digit separator - this is referred to as its precision.
+
+Rust implements the IEEE 754-2008 "binary32" and "binary64" floating-point types as `f32` and `f64`, respectively.
+The f32 type is a single-precision float, and f64 has double precision.
+
+- `f32`: 32 bit floating point precision. Written as `2.45_f32`.
+- `f64`: 64 bit floating point precision. This is default in rust. Written as
+  `2.45_f64`.
+
+```rust
+fn main() {
+    let x = 2.0; // f64
+
+    let y: f32 = 3.0; // f32
+}
+```
+
+As can be seen, each type can store a different number of digits.
+This means that trying to store PI in a `float` will only store the first 6 to 9 digits (with the last digit being rounded).
+
+## Conditional Loops with while
+
+In this exercise you may also want to use a loop.
+There are several ways to write loops in Rust, but the `while` loop is most appropriate here:
+
+```rust
+let mut x = 10;
+
+while x > 0 {
+    // Execute logic if x > 10
+    x = x - 1;
+}
+```
+
+In the above example, we define a `while` loop with the condition `x > 0`.
+Since the initial value of `x` was set to `10` and we decrement it by 1 every
+loop, this will run the code inside the curly braces 10 times.

exercises/concept/interest-is-interesting/.gitignore

@@ -0,0 +1,8 @@
+# Generated by Cargo
+# will have compiled files and executables
+/target/
+**/*.rs.bk
+
+# Remove Cargo.lock from gitignore if creating an executable, leave it for libraries
+# More information here http://doc.crates.io/guide.html#cargotoml-vs-cargolock
+Cargo.lock

exercises/concept/interest-is-interesting/.meta/config.json

@@ -0,0 +1,21 @@
+{
+  "authors": [
+    "devkabiir"
+  ],
+  "forked_from": [
+    "csharp/interest-is-interesting"
+  ],
+  "files": {
+    "solution": [
+      "src/lib.rs",
+      "Cargo.toml"
+    ],
+    "test": [
+      "tests/interest-is-interesting.rs"
+    ],
+    "exemplar": [
+      ".meta/exemplar.rs"
+    ]
+  },
+  "blurb": "Learn about floating point numbers by adding interest to savings accounts."
+}

exercises/concept/interest-is-interesting/.meta/design.md

@@ -0,0 +1,49 @@
+# Design
+
+## Learning objectives
+
+- Know how number literals are represented in Rust
+- Know the different types of integer and floating point primitives
+- Know how to round floats 
+- Know how to write while loops
+- Know how to use if statements
+
+## Out of scope
+
+- High precision floating point arithmetic.
+- Decimals and crates that provide such.
+
+## Concepts
+
+- Numbers
+- Integers
+- Floating point values (basic)
+- If statements
+- While loops
+
+## Prerequisites
+
+None
+
+## Resources to refer to
+
+### Hints
+
+[Rust book - Scalar types](https://doc.rust-lang.org/stable/book/ch03-02-data-types.html?highlight=primitive#scalar-types)
+[cheats.rs - Basic Types](https://cheats.rs/#basic-types)
+[Rust reference - Integer literals](https://doc.rust-lang.org/stable/reference/tokens.html#integer-literals)
+[Rust reference - Floating point literals](https://doc.rust-lang.org/stable/reference/tokens.html#floating-point-literals)
+
+### After
+
+[Rust reference - Literals](https://doc.rust-lang.org/stable/reference/expressions/literal-expr.html)
+[Rust reference - Numeric types](https://doc.rust-lang.org/stable/reference/types/numeric.html)
+[Rust reference - Type cast expressions](https://doc.rust-lang.org/stable/reference/expressions/operator-expr.html#type-cast-expressions)
+
+## Representer
+
+This exercise does not require any specific representation logic to be added to the representer.
+
+## Analyzer
+
+This exercise does not require any specific logic to be added to the analyzer.

exercises/concept/interest-is-interesting/.meta/exemplar.rs

@@ -0,0 +1,35 @@
+pub fn interest_rate(balance: f64) -> f64 {
+    if balance < 0.0 {
+        return 3.213;
+    }
+
+    if balance < 1000.0 {
+        return 0.5;
+    }
+
+    if balance < 5000.0 {
+        return 1.621;
+    }
+
+    return 2.475;
+}
+
+pub fn interest(balance: f64) -> f64 {
+    return balance * interest_rate(balance) / 100.0;
+}
+
+pub fn annual_balance_update(balance: f64) -> f64 {
+    return balance + interest(balance);
+}
+
+pub fn years_before_desired_balance(balance: f64, target_balance: f64) -> u8 {
+    let mut accumulating_balance = balance;
+    let mut years = 0;
+
+    while accumulating_balance < target_balance {
+        accumulating_balance = annual_balance_update(accumulating_balance);
+        years += 1;
+    }
+
+    return years;
+}

exercises/concept/interest-is-interesting/Cargo.toml

@@ -0,0 +1,4 @@
+[package]
+name = "interest_is_interesting"
+version = "0.1.0"
+edition = "2021"

exercises/concept/interest-is-interesting/src/lib.rs

@@ -0,0 +1,15 @@
+pub fn interest_rate(_balance: f64) -> f64 {
+    unimplemented!("Implement interest_rate")
+}
+
+pub fn interest(_balance: f64) -> f64 {
+    unimplemented!("Implement interest")
+}
+
+pub fn annual_balance_update(_balance: f64) -> f64 {
+    unimplemented!("Implement annual_balance_update")
+}
+
+pub fn years_before_desired_balance(_balance: f64, _target_balance: f64) -> u8 {
+    unimplemented!("Implement years_before_desired_balance")
+}