Merge branch 'main' into javascript-dom-method-querySelectorAll

Author: DimitrovErik

content/cpp/concepts/sets/terms/find/find.md

@@ -0,0 +1,159 @@
+---
+Title: '.find()'
+Description: 'Searches for a specific element in a C++ STL set.'
+Subjects:
+  - 'Computer Science'
+  - 'Game Development'
+Tags:
+  - 'Algorithms'
+  - 'Iterators'
+  - 'Sets'
+CatalogContent:
+  - 'learn-c-plus-plus'
+  - 'paths/computer-science'
+---
+
+The **`.find()`** method in C++ searches for a specific element in a `std::set`. If the element is found, `.find()` returns an iterator pointing to the element; otherwise, it returns an iterator to `set.end()`. This method is part of the Standard Template Library (STL).
+
+It allows efficient lookups in `std::set`, which is typically implemented as a balanced binary search tree. This ensures an average time complexity of **`O(log n)`** for lookups.
+
+## Syntax
+
+```pseudo
+std::set<data_type>::iterator it = set_name.find(value);
+```
+
+**Parameters:**
+
+- **`set_name`**: The name of the `std::set` being searched.
+- **`value`**: The element to search for in the set.
+
+**Return Value:**
+
+- If the element is found, it returns an iterator pointing to the element.
+- If the element is not found, it returns an iterator to `set.end()`.
+
+## Examples
+
+### Finding an Element in a Set
+
+The following example demonstrates how to search for an element in a `std::set` and determine whether it exists.
+
+```cpp
+#include <iostream>
+#include <set>
+
+int main() {
+ std::set<int> numbers = {10, 20, 30, 40, 50};
+ int searchValue = 30;
+
+ auto it = numbers.find(searchValue);
+
+ if (it != numbers.end()) {
+  std::cout << "Element found: " << *it << std::endl;
+ } else {
+  std::cout << "Element not found" << std::endl;
+ }
+
+ return 0;
+}
+```
+
+The output will be:
+
+```shell
+Element found: 30
+```
+
+### Checking if a Product Exists in Inventory
+
+This example shows how `.find()` helps determine whether a product ID exists in the inventory.
+
+```cpp
+#include <iostream>
+#include <set>
+
+int main() {
+ std::set<int> productIDs = {101, 202, 303, 404, 505};
+ int searchID = 303;
+ std::set<int>::iterator it = productIDs.find(searchID);
+
+ if (it != productIDs.end()) {
+  std::cout << "Product ID " << searchID << " is available in inventory."
+            << std::endl;
+
+ } else {
+  std::cout << "Product ID " << searchID << " is not in inventory."
+            << std::endl;
+ }
+
+ return 0;
+}
+```
+
+The output will be:
+
+```shell
+Product ID 303 is available in inventory.
+```
+
+### Searching for Employees in a Company Directory
+
+This example uses `.find()` to search for an employee’s name in a directory, ensuring efficient access to records.
+
+```cpp
+#include <iostream>
+#include <set>
+#include <string>
+
+struct CompareIgnoreCase {
+ bool operator()(const std::string &a, const std::string &b) const {
+  return a < b;
+ }
+};
+
+int main() {
+ std::set<std::string, CompareIgnoreCase> names = {"Alice", "Bob", "Charlie"};
+ std::string searchName = "Bob";
+ auto it = names.find(searchName);
+
+ if (it != names.end()) {
+  std::cout << "Name found: " << *it << std::endl;
+
+ } else {
+  std::cout << "Name not found." << std::endl;
+ }
+
+ return 0;
+}
+```
+
+The output will be:
+
+```shell
+Name found: Bob
+```
+
+## Codebyte Example
+
+This example demonstrates a simple use of `.find()` in a C++ STL set. It checks for the presence of a specific integer in a set and prints whether the element was found or not.
+
+```codebyte/cpp
+#include <iostream>
+#include <set>
+
+int main() {
+ std::set<int> numbers = {100, 200, 300, 400};
+ int searchValue = 200;
+ auto it = numbers.find(searchValue);
+
+ if (it != numbers.end()) {
+  std::cout << "Found: " << *it << std::endl;
+
+ } else {
+  std::cout << "Not found." << std::endl;
+ }
+
+ return 0;
+}
+```

content/general/concepts/algorithm/terms/huffman-coding/huffman-coding.md

@@ -0,0 +1,111 @@
+---
+Title: 'Huffman Coding'
+Description: 'A lossless data compression algorithm that assigns variable-length codes to input characters based on their frequencies.'
+Subjects:
+  - 'Computer Science'
+  - 'Code Foundations'
+Tags:
+  - 'Algorithms'
+  - 'Data Structures'
+  - 'Search Algorithms'
+CatalogContent:
+  - 'learn-python-3'
+  - 'paths/computer-science'
+---
+
+**Huffman coding** is a popular algorithm for lossless data compression that assigns variable-length codes to input characters based on their frequencies. Characters that appear more frequently in the data are assigned shorter codes, while less frequent characters receive longer codes. This approach minimizes the overall space required to represent the original data.
+
+The algorithm was developed by David A. Huffman in 1952 while he was a Ph.D. student at MIT. It has since become a fundamental technique in information theory and is used in many compression formats and transmission protocols.
+
+## How Huffman Coding Works
+
+Huffman coding works through the following steps:
+
+- Frequency Analysis: Count the frequency of each character in the input data.
+- Build the Huffman Tree:
+  - Create a leaf node for each character and add it to a priority queue, with priority based on frequency (lower frequency = higher priority).
+  - While there is more than one node in the queue:
+    - Remove the two nodes with the highest priority (lowest frequency).
+    - Create a new internal node with these two nodes as children, with a frequency equal to the sum of both nodes' frequencies.
+    - Add the new node back to the priority queue.
+  - The remaining node is the root of the Huffman tree.
+- Generate Huffman Codes:
+  - Traverse the tree from the root to each leaf.
+  - Assign '0' for a left branch and '1' for a right branch.
+  - The code for each character is the sequence of 0s and 1s on the path from the root to the character's leaf node.
+- Encoding: Replace each character in the original data with its corresponding Huffman code.
+
+## Example
+
+Let's use a simple example to illustrate Huffman coding. Consider encoding the string "ABRACADABRA":
+
+### Step 1: Calculate Character Frequencies
+
+| Character | Frequency |
+| --------- | --------- |
+| A         | 5         |
+| B         | 2         |
+| R         | 2         |
+| C         | 1         |
+| D         | 1         |
+
+### Step 2: Build the Huffman Tree
+
+Starting with leaf nodes for each character:
+
+```plaintext
+A(5)  B(2)  R(2)  C(1)  D(1)
+```
+
+First, combine the two lowest frequency nodes (C and D):
+
+![Huffman Coding Tree Example](https://raw.githubusercontent.com/Codecademy/docs/main/media/huffman_coding_1.png)
+
+```plaintext
+Remaining: A(5) B(2) R(2) [2]
+```
+
+Next, combine the [2] node with another lowest frequency node (B or R, both have 2):
+
+![Huffman Coding Tree Example](https://raw.githubusercontent.com/Codecademy/docs/main/media/huffman_coding_2.png)
+
+```plaintext
+Remaining: A(5) R(2) [4]
+```
+
+Combine R with the [4] node:
+
+![Huffman Coding Tree Example](https://raw.githubusercontent.com/Codecademy/docs/main/media/huffman_coding_3.png)
+
+```plaintext
+Remaining: A(5) [6]
+```
+
+Finally, combine the remaining nodes:
+
+![Huffman Coding Tree Example](https://raw.githubusercontent.com/Codecademy/docs/main/media/huffman_coding_4.png)
+
+## Step 3: Generate Huffman Codes
+
+Assigning 0 for left branches and 1 for right branches:
+
+| Character | Path from Root               | Huffman Code |
+| --------- | ---------------------------- | ------------ |
+| A         | Left                         | 0            |
+| R         | Right → Left                 | 10           |
+| B         | Right → Right → Right        | 111          |
+| C         | Right → Right → Left → Left  | 1100         |
+| D         | Right → Right → Left → Right | 1101         |
+
+## Step 4: Encode the String
+
+Now encode "ABRACADABRA":
+
+```
+A   B   R   A   C   A   D   A   B   R   A
+0  111 10   0  1100 0  1101 0  111  10  0
+```
+
+Without spaces: `01111001100011010111100`
+
+The encoded string is 23 bits long, compared to 88 bits if using 8-bit fixed-length encoding (11 characters × 8 bits = 88 bits), achieving approximately 74% compression.

content/javascript/concepts/dom-manipulation/terms/appendChild/appendChild.md

@@ -0,0 +1,65 @@
+---
+Title: '.appendChild()'
+Description: 'Appends a node as the last child to a parent node in the DOM.'
+Subjects:
+  - 'Web Development'
+  - 'Web Design'
+Tags:
+  - 'Arguments'
+  - 'DOM'
+  - 'ES6'
+  - 'Functions'
+CatalogContent:
+  - 'introduction-to-javascript'
+  - 'paths/front-end-engineer-career-path'
+---
+
+The **`.appendChild()`** method in JavaScript is a key DOM manipulation tool that appends a node (element or text node) as the last child of a specified parent. It allows developers to dynamically modify a webpage’s structure. If the node already exists in the DOM, it is moved to its new position. The method returns the appended node.
+
+## Syntax
+
+```pseudo
+parentNode.appendChild(childNode);
+```
+
+- `parentNode`: The parent element to which the `childNode` will be appended.
+- `childNode`: The node to append (element or text node).
+
+> **Notes:**
+>
+> - If `childNode` already exists in the DOM, it is moved to the new position instead of being duplicated.
+> - Unlike `.append()`, `.appendChild()` accepts only a single node and does not support multiple nodes or strings.
+
+## Example
+
+The following example shows how to use `.appendChild()` to add a paragraph to a `<div>`.
+
+Here is the HTML code:
+
+```html
+<div id="container">
+  <p>This paragraph was added with appendChild!</p>
+</div>
+```
+
+Here is the JavaScript code:
+
+```js
+// Select the parent node
+const parentDiv = document.getElementById('container');
+
+// Create a new paragraph element
+const newParagraph = document.createElement('p');
+
+// Add text content to the element
+newParagraph.textContent = 'This paragraph was added with .appendChild()!';
+
+// Append it as the last child to the parent node
+parentDiv.appendChild(newParagraph);
+```
+
+The output is of this code is as following:
+
+```plaintext
+This paragraph was added with .appendChild()!
+```

content/javascript/concepts/dom-manipulation/terms/createElement/createElement.md

@@ -0,0 +1,54 @@
+---
+Title: '.createElement()'
+Description: 'Generates a new element node of the specified type.'
+Subjects:
+  - 'Computer Science'
+  - 'Web Design'
+Tags:
+  - 'JavaScript'
+  - 'DOM'
+  - 'Methods'
+  - 'Elements'
+CatalogContent:
+  - 'introduction-to-javascript'
+  - 'paths/front-end-engineer-career-path'
+---
+
+In JavaScript, the **`.createElement()`** [method](https://www.codecademy.com/resources/docs/javascript/methods) of the `document` [object](https://www.codecademy.com/resources/docs/javascript/objects) creates a new element node of the specified type. This method returns an `HTMLElement` instance, which can be modified and appended to the DOM.
+
+## Syntax
+
+```pseudo
+document.createElement(type)
+```
+
+- `type`: A string representing the tag name of the element to be created.
+
+## Example
+
+The following example demonstrates the usage of the `.createElement()` method:
+
+```js
+function addElement() {
+  // Create a div element
+  const myDiv = document.createElement('div');
+
+  // Create a text node containing data
+  const data = document.createTextNode('Hi, Codecademy!');
+
+  // Insert the data into the div element
+  myDiv.appendChild(data);
+
+  // Add the element to the body
+  document.body.appendChild(myDiv);
+}
+
+// Call the function to add the element to the page
+addElement();
+```
+
+The above code dynamically adds the following text to the webpage:
+
+```plaintext
+Hi, Codecademy!
+```