##### Problem Statement
Given a binary search tree (BST), find the lowest common ancestor (LCA) of two given nodes in the BST. The LCA is defined as the lowest node that has both nodes as descendants.

##### Example
```plaintext
Input: root = [6, 2, 8, 0, 4, 7, 9, null, null, 3, 5], p = 2, q = 8
Output: 6

Input: root = [6, 2, 8, 0, 4, 7, 9, null, null, 3, 5], p = 2, q = 4
Output: 2
```

##### Constraints
- All values in the tree are unique.
- p and q are different and both values exist in the BST.

#### Expected Challenge Output
When the function `lowestCommonAncestor` is called with the given example inputs, the expected outputs are:
- For the input `root = [6, 2, 8, 0, 4, 7, 9, null, null, 3, 5], p = 2, q = 8`, the output is `6`.
- For the input `root = [6, 2, 8, 0, 4, 7, 9, null, null, 3, 5], p = 2, q = 4`, the output is `2`.

JavaScript

JavaScript is a high-level, dynamic, and interpreted programming language that is widely used for web development and beyond. It was created in the mid-1990s and has since become one of the most popular and widely used programming languages in the world. JavaScript allows developers to create interactive and dynamic websites, as well as build complex web applications and server-side programs. It is a versatile language that can run on any modern web browser, as well as server environments like Node.js, making it an essential tool for any full-stack web developer.

learn-javascript

Python

Python is a high-level, interpreted, general-purpose programming language. It was created in the late 1980s by Guido van Rossum and has since become one of the most popular programming languages in the world. Python is known for its simple and easy-to-read syntax, making it a great language for beginners to learn, and for experienced developers to write complex applications.

Python is used in a variety of applications, including web development, scientific computing, data analysis, artificial intelligence, and more. It has a large and active community of users and developers who have created many libraries and frameworks that make it easier to build complex applications quickly. Python is also known for its strong support for object-oriented programming and its dynamic typing, which makes it flexible and easy to use.

Overall, Python is a versatile and powerful language that can be used for a wide range of applications, making it a great choice for developers looking to build anything from simple scripts to complex applications.

learn-python

C++ Programming

C++ is a high-level, general-purpose programming language that was created as an extension of the C programming language. It is widely used for developing systems software, game development, and desktop and mobile applications. C++ is known for its performance, efficiency, and versatility, making it a popular choice for developing resource-intensive applications. It is also used in the development of other programming languages, as well as in various scientific and engineering applications. C++ is considered a mid-level language, as it contains both high-level and low-level programming concepts, and provides control over system resources through its use of pointers and manual memory management.

learn-cpp-programming

C Programming

This C fundamentals learning module is designed to teach individuals the basics of programming using the C programming language. The module typically covers the fundamentals of C programming, including topics such as data types, variables, control structures, functions, pointers, and memory management. The module may also cover more advanced topics, such as file handling, dynamic memory allocation, and multithreading.

learn-c-programming

Find Lowest Common Ancestor in BST

find-lowest-common-ancestor-in-bst

Struct

In the vast expanse of programming languages, the C language holds a significant place due to its power and versatility. C provides several structures that help in manipulating and handling data efficiently. One of these structures is a `struct`, formally known as a Structure. A C Structure is a collection of variables of different types under a single name. It provides a straightforward way to represent a data group with diverse kinds of data types.

Structures in C can store variables related to different data types. For instance, a student data group might include name (string), age (integer), roll number (integer), and grades (float or double). Instead of creating four separate variables for each attribute, you can create a single structured variable which encompasses all this data.

### Definition of a Structure

To define a structure, you use the `struct` keyword, followed by an optional structure tag and a list of variables enclosed in curly braces:

```c
struct structure_name {
   data_type member1;
   data_type member2;
   ...
};
```

Example:

```c
struct student {
   char name[50];
   int roll;
   float marks;
};
```

Here, `struct` is a keyword, `student` is a structure tag, while `name`, `roll`, and `marks` are members of the structure. Each member has a data type as string, int, and float, respectively.

### Declaration and Accessing Data 

After a structure type is defined, you can declare structure variables of that type. Here's an example:

```c
struct student stud1;
```

You access the members of a structure using the dot (`.`) operator:

```c
strcpy(stud1.name, "John Doe");
stud1.roll = 123;
stud1.marks = 98.5;
```

In the above expressions, `strcpy` function is used to copy a string into the `name` field. Other members are accessed normally.

### Using Structure Pointers

Just like other variables, we can have pointers to a structure. If `ptr` is a pointer to a structure then to access the members of the structure, the `->` operator is used.

```c
struct student *ptr;
ptr = &stud1;
printf("Name: %s\n", ptr->name);
printf("Roll: %d\n", ptr->roll);
printf("Marks: %.2f\n", ptr->marks);
```

This segment will provide the same output as the earlier example, the primary difference lies in the way we accessed the structure elements.

### Conclusion

Structures in C offer a powerful and effective way to group different variables into a single logical unit. They give the flexibility to store different types of data in a structured and coherent manner. From building complex data structures like trees, lists and more, to storing simple groupings of variables - structures provide a useful and diverse tool in a programmer's arsenal. Make sure to practice using structures and their pointers to become comfortable with their syntax and usage.

Functions and Recursion

In the cinematic sphere of programming, functions serve as the shooters behind the camera, overseeing and regulating the movie. They play a significant role in breaking down the script (code), making it more manageable and reducing redundancy. Similar to a movie director dictating where the frame begins and ends, a function in C++ dictates how a certain set of instructions will be executed. In this tutorial, we will navigate the labyrinth of C++ functions and dive into the spellbinding magic of recursion.

To begin with, let's understand how functions work. In C++, a function is a block of code that performs a specific task or a group of related tasks. The structure of a function looks like this:

```cpp
<return_type> <function_name>(<parameter_list>){
    // Function Body
}

```

Using a movie analogy, let's create a function named `printActorName`:

```cpp
void printActorName(std::string actorName) {
    std::cout << "Actor's name is: " << actorName << std::endl;
}

```
In this code, `void` is the return type, signaling that our function does not return any value. `printActorName` is the name of our function, and inside the parentheses, we declare a `string` parameter named `actorName`. This function, when called with a string argument, will print that string following the message "Actor's name is:".

We would call the function `printActorName()` in the main function like so:

```cpp
int main() {
    printActorName("Leonardo DiCaprio");
    return 0;
}

```

In the world of programming, where your code can often mirror the complexity of Inception, functions can also return values, much like the totem that lets you differentiate between dreams and reality. Keeping this in mind, let's create a function called `calcMovieDuration` that takes two integers - start time and end time of the movie - and returns the duration.

```cpp
int calcMovieDuration(int startTime, int endTime) {
    int duration = endTime - startTime;
    return duration;
}

```

We would call the `calcMovieDuration()` function like so:

```cpp
int main() {
    int startTime = 9;
    int endTime = 12;
    int duration = calcMovieDuration(startTime, endTime);
    std::cout << "Movie duration is: " << duration << " hours" << std::endl;
    return 0;
}

```

This program finds the difference between the `endTime` and `startTime` and returns it as `duration`. Then, in the `main()` function, the `calcMovieDuration()` function is called with `startTime` and `endTime` as parameters and its returned value is stored in `duration`.

C++ also allows the concept of recursion, akin to our heroes embarking on the inception journey, diving deeper into dreams within dreams. Recursion in programming refers to a function calling itself, creating a loop until a specific condition is met. However, it's essential to define an exit condition, or our heroes would be stuck in a limbo of infinite recursion, much like being trapped in a dream world.

Let's create a function named `countDown` that uses recursion to count down from a given number:

```cpp
void countDown(int num) {
    if (num <= 0) {
       std::cout << "Blast off!" << std::endl;
        return;
    } else {
        std::cout << num << ", ";
        countDown(num-1); // Self calling function or recursive call
    }
}

```

We would call the `countDown()` function like so:

```cpp
int main() {
    countDown(5);
    return 0;
}

```

In the function `countDown`, we're taking an integer as input. If the number is less than or equal to zero, we print "Blast off!" and terminate the function. However, if the number is greater than zero, we print the number, decrement it, and call the `countDown()` function again. This continues until the number is zero, creating a counting down effect.

Functions in C++, just like movie directors, can take complex, convoluted scripts and transform them into beautiful, cohesive stories that are easier to follow and manage. Understanding and correctly using functions can save you from redundancy and unnecessary complexity, thereby making your life, or rather your coding experience, far easier. Recursion might seem like a daunting concept, but with practice and careful application, you can wield this tool like a master, creating highly efficient and effective code.


Dynamic Memory Management

Dynamic Memory Management in C++ is a critical aspect of a developer's toolbox. Typically, when a variable is declared, the compiler allocally determines the amount of memory to be set aside for that variable. When the variable is no longer in use, the set aside memory is reclaimed. However, in certain scenarios, a program might need to allocate memory at runtime. This is where dynamic memory management comes in. This tutorial chapter aims to shed light on dynamic memory management in C++ using various examples.

Unlike Java where memory allocation and deallocation is handled by the Garbage Collector, in C++, it is the programmer's responsibility to carefully manage dynamic memory, to prevent memory leaks and other related issues.

The keywords 'new' and 'delete' in C++ are used for dynamic memory allocation and deallocation respectively. 

Imagine you are directing a movie named 'MatrixConstruct', and you want to dynamically create new characters during the runtime of the movie as per the script's requirement. Here's how you can do it.

```cpp
// Character structure definition
struct Character {
    std::string name;
    std::string role;

    // Constructor
    Character(std::string name_, std::string role_) : name(name_), role(role_) {}

    // Shows character details
    void showCharacter(){
        cout << "Character Name: " << name << ", Role: " << role << endl;
    }
};

// Current Movie scenario (main)
int main() {
    Character* neo = new Character("Neo", "The One");
    neo->showCharacter();
    // Don't forget to clean up
    delete neo;  
    return 0;
}
```
Here, 'neo' is a pointer to a Character object which is created using 'new'. Once we're done with the 'neo' character, we need to ensure to 'delete' it, else we'll end up with a memory leak.

Now consider a situation where we need to create a collection of characters who form part of an organization named "Zion". Array can be used here, but we only prefer to use arrays when we know the count of characters beforehand. If we need to declare a list of characters at runtime—as in our case—we need to use dynamically allocated arrays.

```cpp
// Create Zion organization characters
int characterCount;
cout << "Enter the number of characters: ";
cin >> characterCount;

Character **zion = new Character*[characterCount];
for(int i = 0; i < characterCount; ++i) {
    string name, role;
    cout << "Enter name for character " << i+1 << ": ";
    cin >> name;
    cout << "Enter role for character " << i+1 << ": ";
    cin >> role;
    zion[i] = new Character(name, role);
}

// Display characters
for(int i = 0; i < characterCount; ++i) {
    zion[i]->showCharacter();
}

// Clean up
for(int i = 0; i < characterCount; ++i) {
    delete zion[i];
}
delete[] zion;

return 0;
```
In the above piece of code, 'zion' is a dynamic array of Character pointers which are each pointing to individual Character objects. Once we're done displaying the characters, we need to loop through the array and 'delete' each character. Lastly, we also need to 'delete' the dynamic array 'zion' itself.

Always remember, for every 'new', there should be a 'delete'. It is pivotal to deallocate or 'delete' any memory that was previously allocated with 'new'. Failing to do so will cause a memory leak, wherein the memory space remains occupied but cannot be utilized or recovered until the program terminates. In large scale software or long-running systems, this could lead to significant issues as the system can run out of memory.

Understanding dynamic memory management in C++ is crucial, especially for resource-constrained environments and when dealing with large amounts of data. It provides developers with the power to manage system resources efficiently, at the cost of adding manual memory management tasks. Moreover, it also enables more complex data structures like linked lists and binary trees, which can be dynamically enlarged or shrunk, allowing for highly adaptable and efficient software solutions. 

In a future chapter, we will explore more complex uses of dynamic memory through data structures and more real-world examples. For now, practice remembering the 'new' must always be paired with 'delete', and understanding how dynamic allocation is often crucial to manage complex, flexible data structures, and ultimately, creating an epic adventure like 'MatrixConstruct'.

DOM Manipulation

DOM, which stands for "Document Object Model," is a programming interface for web documents. It is essentially a structure representing the document as a logical tree structure where each part of the tree ends with a node, and each node contains objects. With DOM, JavaScript has the power to manipulate the content and structure of a website. In this chapter, we will discuss how JavaScript interacts with the DOM and influences web pages.

**Understanding the Document Object Model**

Before we delve deeply into JavaScript DOM manipulation, you need a solid understanding of the DOM itself. When a web page is loaded, the web browser creates a Document Object Model of the page as a tree-like structure. 

For example, consider a simple webpage with a body containing a div, which in turn contains a paragraph. The Document Object Model of this webpage looks something like this.

Document
   |
   |- HTML
       |
       |- Body
           |
           |- div
               |
               |- p


This tree-like representation aids JavaScript in finding HTML elements and manipulating them.

**Accessing Dom Elements**

The first step to manipulating a DOM structure is accessing the elements. JavaScript provides many methods to access DOM elements. They include:

1. document.getElementById(id): Gets the element with the specified ID
2. document.getElementsByClassName(name): Gets a list of elements with the specified class name
3. document.getElementsByTagName(name): Gets a list of elements with the specified tag name
4. document.querySelector(selector): Returns the first element that matches the CSS selector
5. document.querySelectorAll(selector): Returns all elements that match the CSS selector

```javascript
// getting the element with an ID of 'myDiv'
var myDiv = document.getElementById('myDiv');

// getting all elements with a class of 'highlight'
var highlights = document.getElementsByClassName('highlight');

// getting all <p> elements
var paragraphs = document.getElementsByTagName('p');

// getting the first <div> element with class 'highlight'
var firstHighlight = document.querySelector('div.highlight');

// getting all <div> elements with class 'highlight'
var allHighlights = document.querySelectorAll('div.highlight');
```

**Manipulating DOM Elements**

After accessing the elements, you can alter their content, change their styles, or even create new elements. Some of the basic techniques include:

1. innerHTML: Change the HTML content of an element
2. style: Change the CSS styles of an element
3. setAttribute: Set an attribute value in an element
4. createElement: Create a new HTML element

```javascript
// changing the HTML content of our previously accessed 'myDiv'
myDiv.innerHTML = "<h2>Hello, world!</h2>";

// changing the color of 'myDiv' to blue
myDiv.style.color = "blue";

// adding a class to 'myDiv'
myDiv.setAttribute("class", "myClass");

// creating a new <p> element
var newParagraph = document.createElement("p");
```
**Adding and Removing Elements**

In addition to altering existing elements, you can also add new elements to your DOM or remove the existing ones.

```javascript
// appending the new paragraph to 'myDiv'
myDiv.appendChild(newParagraph);

// removing the first highlighted <div> from the document
if (firstHighlight && firstHighlight.parentNode) {
    firstHighlight.parentNode.removeChild(firstHighlight);
}
```

In conclusion, JavaScript has an extensive set of functions and methods for maneuvering DOM elements. Thus, it provides us the ability to control a webpage dynamically and interactively. Keep in mind that the above code snippets are just a starting point, and there’s a lot more you can do with Javascript and the DOM!

JSON

JavaScript Object Notation, widely known as JSON, is a lightweight data-interchange format that is easy for humans to read and write and also easy for machines to parse and generate. JSON is a popular data format with diverse uses in data parsing and to transmit data from a server to a web page. Therefore, learning how to work with JSON is crucial in modern web development. It is text-based, written with JavaScript object notation, and offers a simple way to store complex data structures.

JSON primarily involves two types of syntax:

1. Key-value pairs: JSON data is written as key and value pairs, similar to how objects work in JavaScript.

2. Array: Just like JavaScript, an array in JSON can store multiple values.

Before we start discussing JSON in code, you must understand that JSON is not JavaScript but a format of text that uses similar syntax as JavaScript – meaning you can use JSON independently with many programming languages apart from JavaScript.

An example of a simple JSON object is as shown below:

```json
{
  "firstName": "John",
  "lastName": "Doe",
  "age": 30,
  "address": {
    "street": "21 2nd Street",
    "city": "New York",
    "state": "NY",
    "postalCode": "10021-3100"
  }
}
```

In the above example, you can access individual properties by referencing their corresponding keys. For example, if saved in a variable called `profile`, you can access the age key, as `profile.age`.

JSON is often used with data APIs. Here it is how you fetch JSON data from a URL.

```javascript
fetch('https://api.example.com/user') // change to your JSON feed
.then(response => response.json())
.then(data => console.log(data));
```

In the code above, fetch is used to send a request to a URL and return a Promise. Once the Promise resolves, a response object is returned, which is then parsed as JSON and printed to the console.

JSON is also used to transmit data between a server and a web application, serving as an alternative to XML. JavaScript has a built-in function named `JSON.parse()` to convert JSON data into a JavaScript object. Let's take an example:

```javascript
let jsonData = '{"name":"John", "age":30, "city":"New York"}';
let jsObject = JSON.parse(jsonData);
console.log(jsObject.name); // Outputs: John
```
In the above code, JSON data is converted into a JavaScript object using the `JSON.parse()` function. Then, you could use that object like a regular JavaScript object.

Conversely, if you need to convert a JavaScript object into JSON, you can use the 'JSON.stringify()' function like so:

```javascript
let jsObject = {name:"John", age:30, city:"New York"};
let jsonData = JSON.stringify(jsObject);
console.log(jsonData); // Outputs: {"name":"John","age":30,"city":"New York"}
```

In this chapter, we have briefly explained what JSON is, its basic syntax, use cases, and how to parse and stringify JSON data in JavaScript. In the next segment, we will be building a small project using JSON to help solidify your understanding of JSON in practical use. 

Remember, JSON is not only restricted to JavaScript; it's a language-independent data format that can be used in many programming languages. So understanding JSON allows you a wide range of possibilities across various languages.

Recursion

Recursion is a programming paradigm that involves solving a problem by breaking it down into smaller sub-problems of the same kind. This approach can be highly effective when dealing with complex problems that require repeated calculations or processing. In JavaScript, recursion is implemented using functions that call themselves repeatedly until a base case is reached.

Recursion is not a new concept in programming, and it has been around for decades. However, the rise of JavaScript as a popular programming language has made it an increasingly popular method for solving complex problems. Recursive programming in JavaScript can be highly effective when dealing with large datasets or complex algorithms that require repeated calculations.

In this article, we will explore what recursion is and how to use it effectively in JavaScript. We will also cover some common use cases for recursion in JavaScript and provide examples of code to illustrate our points.

##### What is Recursion?

Recursion is the process of a function calling itself repeatedly until a base case is reached. A base case is a condition that causes the function to terminate without further calls to itself. The key idea behind recursion is that a complex problem can be broken down into smaller sub-problems that are easier to solve.

Recursion can be used in many different programming languages, including JavaScript. In JavaScript, a recursive function looks very similar to any other function, with the exception of one important difference: it calls itself. A common example of a recursive function is the factorial function.

##### The Factorial Function

The factorial function is a mathematical function that takes an integer as input and returns its factorial value. The factorial of a number n is defined as the product of all positive integers from 1 to n. For example, the factorial of 5 (written as 5!) is equal to 5 x 4 x 3 x 2 x 1 = 120.

To calculate the factorial of a number in JavaScript using recursion, we can define a function that takes an integer n and calls itself repeatedly until it reaches a base case:

```js
function factorial(n) {
  if (n === 0) {
    return 1; // base case: the factorial of 0 is 1
  } else {
    return n * factorial(n - 1); // recursive call
  }
}
```

In this code, we define a function called `factorial` that takes an integer as input. If the number is equal to 0 (the base case), we return 1. Otherwise, we use recursion to calculate the factorial of n - 1 and multiply it by n. This process continues until we reach the base case, at which point the function stops calling itself and returns the final result.

##### Another Example: Finding the Length of a List

Recursion can be used in many different ways to solve problems in JavaScript. For example, let's say we want to find the length of a list without using a for loop or any other iterative method. We could use recursion to calculate the length of the list by calling itself repeatedly until it reaches an empty array (the base case).

Here is an example of how to use recursion to find the length of a list in JavaScript:

```js
function length(arr) {
  if (arr.length === 0) { // base case: an empty array has a length of 0
    return 0;
  } else {
    return 1 + length(arr.slice(1)); // recursive call with sliced array
  }
}
```

In this code, we define a function called `length` that takes an array as input. If the array is empty (the base case), we return 0. Otherwise, we use recursion to calculate the length of the array by slicing off the first element and calling `length` on the remaining elements in the array. This process continues until we reach the base case, at which point the function stops calling itself and returns the final result.

##### Common Use Cases for Recursion in JavaScript

Recursion can be used to solve a wide variety of problems in JavaScript. Some common use cases for recursion include:

- Sorting algorithms: Many sorting algorithms, such as quicksort or mergesort, use recursion to divide the input data into smaller subsets that are easier to sort.
- Tree traversal: Recursion can be used to traverse trees and perform operations on each node in the tree.
- Depth-first search: Recursion is often used to implement depth-first search algorithms, which explore all possible paths in a graph or tree before backtracking.
- Generating Fibonacci numbers: The Fibonacci sequence can be generated using recursion by calling itself repeatedly with different arguments.

In conclusion, recursion is an important programming paradigm that can help us solve complex problems using functions that call themselves repeatedly until a base case is reached. While recursive programming can be more difficult to understand than iterative programming, it offers many advantages for solving certain types of problems in JavaScript. By mastering the art of recursion, we can become better programmers and tackle more challenging problems with ease.

Namespaces

Understanding the concept of namespaces is crucial in Python as it ensures the uniqueness of an object, variable, or a function in the code. In this tutorial, we will delve into namespaces in Python: what they are, why we use them, and how they work.

The term 'namespace' refers to a system that has a unique name for each and every object in Python. An object might be a variable or a method. Python implements these namespaces in the form of dictionaries, and they have a name as key mapped to a corresponding object as a value.

Python uses namespaces to manage different scopes of variable names, to ensure that there is no conflict or overlap in names. These namespaces are also hierarchical, thus forming a namespace tree. 

There are mainly three types of namespaces available in Python:

1. Built-in Namespace: As soon as we start a Python interpreter, the built-in namespace gets created and exists as long as the interpreter runs. It includes built-in functions and built-in exception names.

2. Global Namespace: When we start a script, this namespace is created. It remains available until the program ends. Definition of variables inside the script but outside any function belongs to this namespace.

3. Local Namespace: This namespace gets created when a function is called, and it is related to the current function or method. After the function execution ends, the scope of these variables also ends.

Here's a simple example to understand Python namespaces:

```python
var1 = 5 # This will go in global namespace

def func():
    var2 = 6 # This is in local namespace
    print("This is a local variable: ", var2)

func()

print("This is a global variable: ", var1)
```

In the above example, the variable var1 is in the global namespace, and var2 is in the local namespace of the function func().

Although local and global variables can share the same name, Python clearly distinguishes them. Let's add to our example:

```python
var1 = 5 # This will go in global namespace

def func():
    var1 = 6 # Now var1 is in local namespace
    print("This is a local variable: ", var1)

func()

print("This is a global variable: ", var1)
```

In this case, the output will be:

```
This is a local variable:  6
This is a global variable:  5
```

Notice that the local namespace takes precedence. Inside func(), var1 refers to the local var1, not the global one. After func() ends, we're back in the global namespace, where var1 is still 5.

In conclusion, understanding namespaces in Python is of utmost importance as it plays a significant role in the scope of a variable. It directly affects how variables are accessed, modified, or created. It not only saves us from unexpected errors and bugs but also makes our program more understandable and manageable.

Find Lowest Common Ancestor in BST

Challenge Instructions

Problem Statement

Example

Constraints

Expected Challenge Output

Test Cases