✨ (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-statemetns"
+        ],
+        "status": "wip"
+      },
       {
         "slug": "lucians-luscious-lasagna",
         "uuid": "29a2d3bd-eec8-454d-9dba-4b2d7d071925",

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

@@ -0,0 +1,38 @@
+# Hints
+
+## General
+
+- [Floating-point numeric types introduction][docs.microsoft.com-floating_point_numeric_types].
+
+## 1. Calculate the interest rate
+
+- By default, any floating-point number defined in Rust code is treated as a
+  `f64`.
+- To use `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

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

@@ -0,0 +1,58 @@
+# 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_is_interesting::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_is_interesting::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
+interest_is_interesting::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
+interest_is_interesting::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,38 @@
+# 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).
+
+## While Loops
+
+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 = 23;
+
+while x > 10 {
+    // Execute logic if x > 10
+    x = x - 2;
+}
+```

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")
+}