Merge branch 'main' into fix-javascript-arguments-description

Author: mamtawardhani

bin/concept-of-the-week.txt

@@ -1 +1 @@
-content/kotlin/concepts/variables/variables.md
+content/kotlin/concepts/classes/classes.md

content/cpp/concepts/unordered-set/terms/cbegin/cbegin.md

@@ -0,0 +1,104 @@
+---
+Title: 'cbegin()'
+Description: 'Returns a constant iterator pointing to either the first element of the unordered set or the first element in a specific bucket.'
+Subjects:
+  - 'Code Foundations'
+  - 'Computer Science'
+Tags:
+  - 'Iterators'
+  - 'Sets'
+  - 'STL'
+CatalogContent:
+  - 'learn-c-plus-plus'
+  - 'paths/computer-science'
+---
+
+The **`cbegin()`** method returns a constant iterator that points to the first element of an [`unordered_set`](https://www.codecademy.com/resources/docs/cpp/unordered-set). A constant iterator allows read-only access to elements and prevents modification. Because `unordered_set` does not maintain any defined order, the element returned by `cbegin()` depends on its internal hash table structure.
+
+## Syntax
+
+```pseudo
+unordered_set_name.cbegin(n);
+```
+
+**Return value:**
+
+Returns a `const_iterator` (constant iterator) pointing to the first element in the `unordered_set`.
+
+Or, alternatively:
+
+```pseudo
+unordered_set_name.cbegin(n);
+```
+
+**Parameters:**
+
+- `n` (size_type): The bucket index. Must be less than `bucket_count()`.
+
+**Return value:**
+
+A `const_local_iterator` pointing to the first element in bucket `n`. If the bucket is empty, the returned iterator equals `cend(n)`.
+
+## Example
+
+This example demonstrates obtaining the starting element of an `unordered_set` using `cbegin()`:
+
+```cpp
+#include <iostream>
+#include <string>
+#include <unordered_set>
+using namespace std;
+
+int main() {
+  unordered_set<int> unique_numbers = {10, 5, 20, 15};
+
+  auto it = unique_numbers.cbegin();
+
+  cout << "The first element in internal order is: " << *it << "\n";
+
+  ++it;
+  if (it != unique_numbers.cend()) {
+    cout << "The second element is: " << *it << "\n";
+  }
+
+  // *it = 99; // Error: cannot modify through const_iterator
+
+  return 0;
+}
+```
+
+A sample output of this code is:
+
+```shell
+The first element in the set's internal order is: 20
+The second element is: 5
+```
+
+> **Note:** Attempting to modify the element pointed to by the `const_iterator` would result in a compilation error.
+
+## Codebyte Example
+
+In this example, the code retrieves a constant iterator for a specific bucket in the `unordered_set` and prints all elements stored in that bucket:
+
+```codebyte/cpp
+#include <iostream>
+#include <unordered_set>
+using namespace std;
+
+int main() {
+  unordered_set<string> words = {"cat", "dog", "rabbit", "lion"};
+
+  size_t bucket = 0;
+
+  auto it = words.cbegin(bucket);
+  auto end = words.cend(bucket);
+
+  cout << "Elements in bucket " << bucket << ":\n";
+
+  for (; it != end; ++it) {
+    cout << "  " << *it << "\n";
+  }
+
+  return 0;
+}
+```

content/matplotlib/concepts/pyplot/terms/plot/plot.md

@@ -0,0 +1,74 @@
+---
+Title: '.plot()'
+Description: 'Creates line and marker plots to visualize relationships between variables in Matplotlib.'
+Subjects:
+  - 'Data Science'
+  - 'Data Visualization'
+Tags:
+  - 'Charts'
+  - 'Matplotlib'
+  - 'Methods'
+  - 'Python'
+CatalogContent:
+  - 'learn-python-3'
+  - 'paths/data-science'
+  - 'paths/data-science-foundations'
+---
+
+The **`.plot()`** function in [Matplotlib](https://www.codecademy.com/resources/docs/matplotlib/pyplot) is the primary method used to create line plots and marker plots. It takes one or two sets of data points (x and y coordinates) and draws lines connecting them, displays markers at each point, or both. This function is one of the most commonly used tools in data visualization for showing trends, patterns, and relationships between variables.
+
+Line plots are ideal for illustrating how data changes over time or across continuous intervals. It's widely used in fields such as statistics, engineering, and data science for exploratory data analysis and model visualization.
+
+## Syntax
+
+```pseudo
+matplotlib.pyplot.plot(*args, scalex=True, scaley=True, data=None, **kwargs)
+```
+
+**Parameters:**
+
+- `*args`: Values for y, or x and y, optionally followed by a format string.
+- `scalex`: Auto-scale the x-axis (default True).
+- `scaley`: Auto-scale the y-axis (default True).
+- `data`: Optional dict or DataFrame for referencing variables by name.
+- `**kwargs`: Style and configuration options like color, label, linewidth, marker.
+
+**Return value:**
+
+Returns a list of `Line2D` objects representing the plotted data.
+
+## Example: Creating a Basic Line Plot
+
+This example demonstrates how to create a simple line plot with plt.plot() to visualize the relationship between two numerical variables:
+
+```py
+import matplotlib.pyplot as plt
+import numpy as np
+
+# Sample data
+x = np.array([1, 2, 3, 4, 5])
+y = np.array([2, 4, 1, 6, 3])
+
+# Create a line plot
+plt.plot(x, y)
+
+# Add labels and a title
+plt.xlabel('X-axis')
+plt.ylabel('Y-axis')
+plt.title('Basic Line Plot Example')
+
+# Add a grid for better readability
+plt.grid(True, linestyle='--', alpha=0.6)
+
+# Display the plot
+plt.show()
+```
+
+This example visualizes the relationship between an independent variable, X-axis, and a dependent variable, Y-axis, using a single continuous line. The plot shows the change in Y values as X increases from 1.0 to 5.0. This plot highlights a few useful details worth noting:
+
+- Single Series: The plot displays one series of data, represented by a single blue line, showing the progression of the Y-axis value relative to the X-axis value.
+- Data Points and Trend: The line connects the following data points: $(1.0, 2.0)$, $(2.0, 4.0)$, $(3.0, 1.0)$, $(4.0, 6.0)$, and $(5.0, 3.0)$. The plot illustrates clear changes in direction: an initial increase, a sharp decrease, a significant increase to the maximum value, and a final decrease.
+- Labels and Title: The plot is clearly titled "Basic Line Plot Example" and has "X-axis" and "Y-axis" labels for clarity.
+- Grid: A light dashed grid is present, running horizontally and vertically across the plot, which aids in precisely reading the coordinate values of the data points off the chart.
+
+![Line plot illustrating a fluctuating, piecewise linear trend between the X-axis and Y-axis, with a single blue line connecting 5 data points, a grid, and labeled axes](https://raw.githubusercontent.com/Codecademy/docs/main/media/matplot-plot-output.png)

content/sql/concepts/joins/joins.md

@@ -40,6 +40,40 @@ An `OUTER JOIN` will combine rows from different tables even if the join conditi
 - [`RIGHT JOIN`](https://www.codecademy.com/resources/docs/sql/commands/right-join), which combines matches with all rows from the right-side table.
 - [`FULL OUTER JOIN`](https://www.codecademy.com/resources/docs/sql/commands/full-outer-join), which combines matches with all rows from the left- and right-side tables.
 
+## CROSS JOIN
+
+A `CROSS JOIN` clause combines each row from one table with each row from another in the result set. This result is also known as a `Cartesian product`. The following query returns every combination of `shirt_color` and `pants_color`:
+
+```sql
+SELECT shirts.shirt_color,
+   pants.pants_color
+FROM shirts
+CROSS JOIN pants;
+```
+
+For example, here's the `shirts` table:
+
+| shirt_color |
+| ----------- |
+| white       |
+| grey        |
+
+And the `pants` table:
+
+| pants_color |
+| ----------- |
+| light       |
+| dark        |
+
+The result of the query would contain every combination of the two tables:
+
+| shirt_color | pants_color |
+| ----------- | ----------- |
+| white       | light       |
+| white       | dark        |
+| grey        | light       |
+| grey        | dark        |
+
 ## UNION
 
 The [`UNION`](https://www.codecademy.com/resources/docs/sql/commands/union) clause is used to combine results that appear from multiple [`SELECT`](https://www.codecademy.com/resources/docs/sql/commands/select) statements and filter duplicates.