Merge branch 'lerp-entry' of https://github.com/alessandrocapialbi/docs into lerp-entry

Author: alessandrocapialbi

content/javascript/concepts/arrays/terms/sort/sort.md

@@ -1,68 +1,111 @@
 ---
 Title: '.sort()'
-Description: 'Returns an array with its items sorted in place.'
+Description: 'Sorts the elements of an array in place.'
 Subjects:
-  - 'Web Development'
   - 'Computer Science'
+  - 'Web Development'
 Tags:
   - 'Arrays'
-  - 'Comparison'
   - 'Functions'
   - 'Methods'
-  - 'Sort'
-  - 'Unicode'
+  - 'Values'
 CatalogContent:
   - 'introduction-to-javascript'
   - 'paths/front-end-engineer-career-path'
 ---
 
-The **`.sort()`** method returns an array with its items sorted in place.
+The JS **`.sort()`** [method](https://www.codecademy.com/resources/docs/javascript/methods) is used to sort the elements of an array in place. By default, it sorts elements as [strings](https://www.codecademy.com/resources/docs/javascript/strings) in ascending order. However, a custom comparison [function](https://www.codecademy.com/resources/docs/javascript/functions) can be provided to achieve more advanced sorting.
 
-## Syntax
+## JS `.sort()` Syntax
 
 ```pseudo
-// No parameters
-array.sort();
-
-// With optional function
-array.sort((firstElement, secondElement) => { /* function body */ };
+arr.sort(compareFn)
 ```
 
-If the `.sort()` method is used with no arguments, all items with `undefined` values are shifted to the end of the array while the remaining items are converted to [strings](https://www.codecademy.com/resources/docs/javascript/strings) and sorted by [Unicode code point value](https://en.wikipedia.org/wiki/Code_point).
+**Parameters:**
 
-An optional function is used to define how items are sorted. This is done by iterating over the `array` and comparing every `firstElement` and `secondElement` in the `/* function body */`.
+- `compareFn` (Optional): A function that defines the sort order. It takes two arguments, `a` and `b`, and should return:
+  - A negative value if `a` should come before `b`
+  - `0` if `a` and `b` are considered equal
+  - A positive value if `a` should come after `b`
 
-## Example
+**Return value:**
 
-In the following example, the `.sort()` method is applied to two arrays, `letters` and `numbers` (a mix of floats and integers):
+JS `.sort()` returns the original array with its elements sorted in the given order.
 
-```js
-const letters = ['d', 'b', 'e', 'a', 'c'];
-const numbers = [5, 2, 123, 5.01, 43.5];
+## Example 1: Sorting Array of Strings Using JS `.sort()`
 
-console.log('Letters: ', letters.sort());
-console.log('Numbers: ', numbers.sort());
+This example uses JS `.sort()` to sort an array of strings:
+
+```js
+const fruits = ['banana', 'apple', 'cherry', 'date'];
+fruits.sort();
+console.log(fruits);
 ```
 
-This results in the following output:
+Here is the output:
 
 ```shell
-Letters: [ 'a', 'b', 'c', 'd', 'e' ]
-Numbers: [ 123, 2, 43.5, 45, 5, 5.01 ]
+[ 'apple', 'banana', 'cherry', 'date' ]
 ```
 
-The `letters` were sorted in alphabetical order. The items in `numbers` were sorted based on the leading number in the item's value (e.g., their Unicode value). Sorting numerical values more strictly requires a custom comparison function.
+## Example 2: Sorting Array of Numbers Using JS `.sort()`
 
-## Codebyte Example
+This example uses JS `.sort()` with a comparison function to sort an array of numbers:
 
-The following example showcases how the optional `callback` argument can be used to sort a `numbers` array in ascending and descending order:
+```js
+const numbers = [10, 5, 20, 1, 100];
+numbers.sort((a, b) => a - b);
+console.log(numbers);
+```
+
+Here is the output:
+
+```shell
+[ 1, 5, 10, 20, 100 ]
+```
+
+## Codebyte Example: Sorting Array of Objects Using JS `.sort()`
+
+This codebyte example uses JS `.sort()` to sort an array of objects:
 
 ```codebyte/javascript
-const numbers = [5, 2, 123, 5.01, 43.5];
+const users = [
+  { name: "Alice", age: 25 },
+  { name: "Bob", age: 20 },
+  { name: "Charlie", age: 30 }
+];
+
+users.sort((a, b) => a.age - b.age);
 
-const ascending = numbers.sort((a, b) => a - b);
-console.log("Ascending order: ", ascending);
+console.log(users);
+```
+
+## Frequently Asked Questions
+
+### 1. How do I sort numbers in descending order using JS `.sort()`?
+
+You can reverse the comparison in your function in JS `.sort()` to sort numbers in descending order:
+
+```js
+numbers.sort((a, b) => b - a);
+```
+
+### 2. Can I use `sort()` on a string?
 
-const descending = numbers.sort((a, b) => b - a);
-console.log("Descending order: ", descending);
+No. The `sort()` method is only available on arrays, not on strings. If you want to sort the characters of a string, you first need to convert it into an array (for example, using `split()`), apply `sort()`, and then join it back:
+
+```js
+const str = 'hello';
+const sorted = str.split('').sort().join('');
+console.log(sorted); // "ehllo"
+```
+
+### 3. What happens when `sort()` is used in a list (array)?
+
+When you call `sort()` on an array, JavaScript converts the elements to strings by default and compares them in Unicode code point order. This means that numbers may not sort as you expect:
+
+```js
+const numbers = [10, 1, 5];
+console.log(numbers.sort()); // [1, 10, 5] (string comparison)
 ```

content/javascript/concepts/sort/sort.md

@@ -1,6 +1,6 @@
 ---
 Title: '.lerp()'
-Description: 'Returns a new tensor as a result of a linear interpolation between two tensors and a scalar or tensor weight.'
+Description: 'Returns a tensor containing the linear interpolation of two tensors, controlled by a scalar or tensor weight.'
 Subjects:
   - 'Computer Science'
   - 'Machine Learning'
@@ -14,8 +14,9 @@ CatalogContent:
   - 'paths/computer-science'
 ---
 
-In PyTorch, the **lerp()** function computes the linear interpolation between two [tensors](https://www.codecademy.com/resources/docs/pytorch/tensors) `start` (from the `input`) and `end` with an auxiliary scalar or tensor `weight`. The result is stored in a new tensor `out`. This is mathematically equivalent to compute the function $out_i = start_i + weight_i * (end_i - start_i)$.
-The shapes of both tensors must be [broadcastable](https://www.codecademy.com/resources/docs/numpy/array-broadcasting). If `weight` is a tensor, then all the shapes of `start`, `end` and `weight` must be [broadcastable](https://www.codecademy.com/resources/docs/numpy/array-broadcasting).
+In PyTorch, the **`.lerp()`** function computes the linear interpolation between an input [tensor](https://www.codecademy.com/resources/docs/pytorch/tensors) (`input`) and an end tensor (`end`), using a scalar or tensor `weight`. This is mathematically equivalent to applying the function $out_i = start_i + weight_i * (end_i - start_i)$.
+
+The shapes of `input`, `end`, and `weight` must be [broadcastable](https://www.codecademy.com/resources/docs/numpy/array-broadcasting).
 
 ## Syntax
 
@@ -27,7 +28,7 @@ torch.lerp(input, end, weight, *, out=None)
 
 - `input`: The input tensor containing the initial points.
 - `end`: The ending tensor containing the finishing points.
-- `weight`: A float scalar or a tensor with the weight for the interpolation formula.
+- `weight`: The shapes of input, end, and weight must be
 - `out` (optional): A tensor to store the output. If provided, the result is written to this tensor.
 
 **Return value:**
@@ -36,7 +37,7 @@ Returns a new tensor containing the result given by the interpolation formula.
 
 ## Example
 
-In this example, we compute the interpolation between two tensors and a float scalar weight `torch.lerp()`:
+The following example shows how to compute the interpolation between two tensors using `torch.lerp()` with a float scalar weight:
 
 ```py
 import torch