JavaScript Exercises

Author: HashimThePassionate

Diff for: 05_arrays_and_objects/09_exerxise/readme.md

@@ -1,24 +1,68 @@
-# Exercises
+# 📘 JavaScript Exercises 
 
-## The Sum of a Range
+## Table of Contents
+1. [🌈 The Sum of a Range](#-the-sum-of-a-range)
+2. [🔄 Reversing an Array](#-reversing-an-array)
+3. [📝 Working with Lists](#-working-with-lists)
+4. [🔍 Deep Comparison](#-deep-comparison)
 
-1. Write a `range` function that takes two arguments, `start` and `end`, and returns an array containing all the numbers from `start` up to and including `end`.
-2. Write a `sum` function that takes an array of numbers and returns the sum of these numbers.
-3. Modify the `range` function to take an optional third argument that indicates the “step” value used when building the array. Ensure that it works with both positive and negative step values.
+## 🌈 The Sum of a Range
 
-## Reversing an Array
+1. **`range` Function**  
+   Create a `range` function that takes two arguments, `start` and `end`, and returns an array containing all numbers between these values, inclusive.
+   
+2. **`sum` Function**  
+   Write a `sum` function that takes an array of numbers and calculates the sum of all elements.
 
-1. Write a function `reverseArray` that takes an array as an argument and produces a new array that has the same elements in the inverse order.
-2. Write a function `reverseArrayInPlace` that modifies the array given as an argument by reversing its elements without using the standard `reverse` method.
+3. **Adding a Step Argument**  
+   Modify the `range` function to take an optional third argument, `step`, that allows the function to skip numbers. Ensure it works with both positive and negative values!
 
-## A List
+   **Hints**:
+   - Think about how the `step` value changes the array construction.
+   - Consider both forward and backward counting based on the step value.
 
-1. Write a function `arrayToList` that builds up a list structure like the one shown when given `[1, 2, 3]` as an argument.
-2. Write a function `listToArray` that produces an array from a list.
-3. Write a helper function `prepend` that takes an element and a list and creates a new list that adds the element to the front of the input list.
-4. Write a function `nth` that takes a list and a number and returns the element at the given position in the list (with zero referring to the first element) or `undefined` when there is no such element.
-5. Write a recursive version of `nth`.
+## 🔄 Reversing an Array
 
-## Deep Comparison
+1. **`reverseArray` Function**  
+   Write a function that takes an array and returns a new array with its elements in reverse order.
 
-1. Write a function `deepEqual` that takes two values and returns `true` only if they are the same value or are objects with the same properties, where the values of the properties are equal when compared with a recursive call to `deepEqual`.
+2. **`reverseArrayInPlace` Function**  
+   Create a function that reverses an array in place, meaning the original array is modified without creating a new array.
+
+   **Tips**:
+   - For `reverseArrayInPlace`, try using a loop to swap elements from the beginning and end until you reach the middle.
+   - Avoid using JavaScript’s built-in `reverse` method to deepen your understanding of array manipulation.
+
+## 📝 Working with Lists
+
+1. **`arrayToList` Function**  
+   Write a function that converts an array into a nested list structure. A list is an object where each element has a `value` and a `rest` property.
+
+2. **`listToArray` Function**  
+   Convert a list back into an array format. 
+
+3. **`prepend` Helper Function**  
+   Write a helper function that adds an element to the front of a list. This function should return a new list with the element prepended.
+
+4. **`nth` Function**  
+   Access a specific element in the list by its position (with zero being the first element). Return `undefined` if the element doesn’t exist.
+
+5. **Recursive `nth` Function**  
+   Write a recursive version of `nth` to practice recursive thinking!
+
+   **Quick Note**:
+   - Lists are often implemented as nested objects, which can be a fun departure from typical arrays. Try to think of each element in the list as a unique object in a chain.
+
+## 🔍 Deep Comparison
+
+1. **`deepEqual` Function**  
+   Write a `deepEqual` function that checks if two values are "deeply equal." In other words, they should have the same values, and if they’re objects, all properties must match as well.
+
+   **Tips**:
+   - Use recursion to handle nested objects.
+   - Remember that `deepEqual` should handle primitive types as well as objects.
+   - Consider cases where one value is `null` or `undefined` to make your function more robust.
+
+### 🌟 Happy Coding! 🌟
+
+These exercises cover a range of essential JavaScript skills, from basic array manipulation to deeper object comparisons. Enjoy exploring these concepts, and remember to write code that’s not only functional but also clear and readable. Good luck! 🚀