fix: Update packages and fix local dev (#26907)

<!-- Please follow this checklist and put an x in each of the boxes, like this: [x]. It will ensure that our team takes your pull request seriously. -->

- [x] I have read [freeCodeCamp's contribution guidelines](https://github.com/freeCodeCamp/freeCodeCamp/blob/master/CONTRIBUTING.md).
- [x] My pull request has a descriptive title (not a vague title like `Update index.md`)
- [x] My pull request targets the `master` branch of freeCodeCamp.

mock-guide/english/algorithms/algorithm-design-patterns/behavioral-patterns/index.md

@@ -0,0 +1,30 @@
+---
+title: Behavioral patterns
+---
+
+## Behavioral patterns
+
+Behavioral design patterns are design patterns that identify common communication problems between objects and realize these patterns. By doing so, these patterns increase flexibility in carrying out this communication, making the software more reliable and easy to mantain.
+
+Examples of this type of design pattern include:
+
+1. **Chain of responsibility pattern**: Command objects are handled or passed on to other objects by logic-containing processing objects.
+2. **Command pattern**: Command objects encapsulate an action and its parameters.
+3. **Interpreter pattern**: Implement a specialized computer language to rapidly solve a specific set of problems.
+4. **Iterator pattern**: Iterators are used to access the elements of an aggregate object sequentially without exposing its underlying representation.
+5. **Mediator pattern**: Provides a unified interface to a set of interfaces in a subsystem.
+6. **Memento pattern**: Provides the ability to restore an object to its previous state (rollback).
+7. **Null Object pattern**: Designed to act as a default value of an object.
+8. **Observer pattern**: a.k.a. P**ublish/Subscribe** or **Event Listener**. Objects register to observe an event that may be raised by another object.
+9. **Weak reference pattern**: De-couple an observer from an observable.
+10. **Protocol stack**: Communications are handled by multiple layers, which form an encapsulation hierarchy.
+11. **Scheduled-task pattern**: A task is scheduled to be performed at a particular interval or clock time (used in real-time computing).
+12. **Single-serving visitor pattern**: Optimize the implementation of a visitor that is allocated, used only once, and then deleted.
+13. **Specification pattern**: Recombinable business logic in a boolean fashion.
+14. **State pattern**: A clean way for an object to partially change its type at runtime.
+15. **Strategy pattern**: Algorithms can be selected on the fly.
+16. **Template method pattern**: Describes the program skeleton of a program.
+17. **Visitor pattern**: A way to separate an algorithm from an object.
+
+### Sources
+[https://en.wikipedia.org/wiki/Behavioral_pattern](https://en.wikipedia.org/wiki/Behavioral_pattern)

mock-guide/english/algorithms/algorithm-design-patterns/index.md

@@ -0,0 +1,27 @@
+---
+title: Algorithm Design Patterns
+---
+## Algorithm Design Patterns
+
+In software engineering, a design pattern is a general repeatable solution to a commonly occurring problem in software design. A design pattern isn't a finished design that can be transformed directly into code. It is a description or template for how to solve a problem that can be used in many different situations. 
+
+Design patterns can speed up the development process by providing tested, proven development paradigms.
+
+This patterns are divided in three major categories:
+
+### Creational patterns
+
+These are design patterns that deal with object creation mechanisms, trying to create objects in a manner suitable to the situation. The basic form of object creation could result in design problems or in added complexity to the design. Creational design patterns solve this problem by somehow controlling this object creation.
+
+### Structural patterns 
+
+These are design patterns that ease the design by identifying a simple way to realize relationships between entities.
+
+### Behavioral patterns
+
+These are design patterns that identify common communication patterns between objects and realize these patterns. By doing so, these patterns increase flexibility in carrying out this communication.
+
+#### More Information:
+<!-- Please add any articles you think might be helpful to read before writing the article -->
+[Design patterns - Wikipedia](https://en.wikipedia.org/wiki/Design_Patterns)
+

mock-guide/english/algorithms/avl-trees/index.md

@@ -0,0 +1,63 @@
+---
+title: AVL Trees
+---
+## AVL Trees
+
+
+An AVL tree is a subtype of binary search tree.
+
+A BST is a data structure composed of nodes. It has the following guarantees:
+
+1. Each tree has a root node (at the top).
+2. The root node has zero or more child nodes.
+3. Each child node has zero or more child nodes, and so on.
+4. Each node has up to two children.
+5. For each node, its left descendents are less than the current node, which is less than the right descendents.
+
+AVL trees have an additional guarantee:
+6. The difference between the depth of right and left subtrees cannot be more than one. In order to maintain this guarantee, an implementation of an AVL will include an algorithm to rebalance the tree when adding an additional element would upset this guarantee.
+
+AVL trees have a worst case lookup, insert and delete time of O(log n).
+
+### Right Rotation
+
+![AVL Tree Right Rotation](https://raw.githubusercontent.com/HebleV/valet_parking/master/images/avl_right_rotation.jpg)
+
+### Left Rotation
+
+![AVL Tree Left Rotation](https://raw.githubusercontent.com/HebleV/valet_parking/master/images/avl_left_rotation.jpg)
+
+### AVL Insertion Process
+
+You will do an insertion similar to a normal Binary Search Tree insertion. After inserting, you fix the AVL property using left or right rotations.
+
+  - If there is an imbalance in left child of right subtree, then you perform a left-right rotation.  
+  - If there is an imbalance in left child of left subtree, then you perform a right rotation.  
+  - If there is an imbalance in right child of right subtree, then you perform a left rotation.  
+  - If there is an imbalance in right child of left subtree, then you perform a right-left rotation.  
+ 
+
+#### More Information:
+[YouTube - AVL Tree](https://www.youtube.com/watch?v=7m94k2Qhg68)
+
+An AVL tree is a self-balancing binary search tree.
+An AVL tree is a binary search tree which has the following properties:
+->The sub-trees of every node differ in height by at most one.
+->Every sub-tree is an AVL tree.
+
+AVL tree checks the height of the left and the right sub-trees and assures that the difference is not more than 1. This difference is called the Balance Factor.
+The height of an AVL tree is always O(Logn) where n is the number of nodes in the tree.
+
+AVL Tree Rotations:-
+
+In AVL tree, after performing every operation like insertion and deletion we need to check the balance factor of every node in the tree. If every node satisfies the balance factor condition then we conclude the operation otherwise we must make it balanced. We use rotation operations to make the tree balanced whenever the tree is becoming imbalanced due to any operation.
+
+Rotation operations are used to make a tree balanced.There are four rotations and they are classified into two types:
+->Single Left Rotation (LL Rotation)
+In LL Rotation every node moves one position to left from the current position.
+->Single Right Rotation (RR Rotation)
+In RR Rotation every node moves one position to right from the current position. 
+->Left Right Rotation (LR Rotation)
+The LR Rotation is combination of single left rotation followed by single right rotation. In LR Rotation, first every node moves one position to left then one position to right from the current position.
+->Right Left Rotation (RL Rotation)
+The RL Rotation is combination of single right rotation followed by single left rotation. In RL Rotation, first every node moves one position to right then one position to left from the current position.

mock-guide/english/algorithms/index.md

@@ -0,0 +1,60 @@
+---
+title: Algorithms
+---
+
+## Algorithms
+
+In computer science, an algorithm is an unambiguous specification of how to solve a class of problems. Algorithms can perform calculations, data processing and automated reasoning tasks.
+
+An algorithm is an effective method that can be expressed within a finite amount of space and time and in a well-defined formal language for calculating a function. Starting from an initial state and initial input (perhaps empty), the instructions describe a computation that, when executed, proceeds through a finite number of well-defined successive states, eventually producing "output" and terminating at a final ending state. The transition from one state to the next is not necessarily deterministic; some algorithms, known as randomized algorithms, incorporate random input.
+
+There are certain requirements that an algorithm must abide by:
+<ol>
+  <li>Definiteness: Each step in the process is precisely stated.</li>
+  <li>Effective Computability: Each step in the process can be carried out by a computer.</li>
+  <li>Finiteness: The program will eventually successfully terminate.</li>
+</ol>
+
+Some common types of algorithms include sorting algorithms, search algorithms, and compression algorithms. Classes of algorithms include Graph, Dynamic Programming, Sorting, Searching, Strings, Math, Computational Geometry, Optimization, and Miscellaneous. Although technically not a class of algorithms, Data Structures are often grouped with them. 
+
+### Efficiency
+
+Algorithms are most commonly judged by their efficiency and the amount of computing resources they require to complete their task. A common way to evaluate an algorithm is to look at its time complexity. This shows how the running time of the algorithm grows as the input size grows. Since the algorithms today, have to be operate on large data inputs, it is essential for our algorithms to have a reasonably fast running time .
+
+### Sorting Algorithms
+
+Sorting algorithms come in various flavors depending on your necessity.
+Some, very common and widely used are:
+
+#### Quick Sort
+
+There is no sorting discussion which can finish without quick sort. The basic concept is in the link below.
+[Quick Sort](http://me.dt.in.th/page/Quicksort/)
+
+#### Merge Sort
+It is the sorting algorithm which relies on the concept how to sorted arrays are merged to give one sorted arrays. Read more about it here-
+[Merge Sort](https://www.geeksforgeeks.org/merge-sort/)
+
+freeCodeCamp's curriculum heavily emphasizes creating algorithms. This is because learning algorithms is a good way to practice programming skills. Interviewers most commonly test candidates on algorithms during developer job interviews.
+
+### Further Resources
+
+[Intro to Algorithms | Crash Course: Computer Science](https://www.youtube.com/watch?v=rL8X2mlNHPM)
+
+This video gives an accessible and lively introduction to algorithms focusing on sorting and graph search algorithms. 
+
+[What is an Algorithm and Why Should you Care? | Khan Academy](https://www.youtube.com/watch?v=CvSOaYi89B4)
+
+This video introduces algorithms and briefly discusses some high profile uses of them. 
+
+[15 Sorting Algorithms in 6 Minutes | Timo Bingmann](https://www.youtube.com/watch?v=kPRA0W1kECg)
+
+This video visually demonstrates some popular sorting algorithms that are commonly taught in programming and Computer Science courses.
+
+[Algorithm Visualizer](http://algo-visualizer.jasonpark.me)
+
+This is also a really good open source project that helps you visualize algorithms. 
+
+[Infographic on how Machine Learning Algorithms Work](https://www.boozallen.com/content/dam/boozallen_site/sig/pdf/infographic/how-do-machines-learn.pdf)
+
+This infographic shows you how unsupervised and supervised machine learning algorithms work..