Merge branch 'Codecademy:main' into main

Author: mamtawardhani

CONTRIBUTING.md

@@ -133,14 +133,6 @@ To link your Codecademy user profile to GitHub:
 - Typos/bugs
 - Plagiarism
 
-## What is the policy for using generative AI?
-
-We will not accept entries that were exclusively generated through an AI tool. We have this policy because:
-
-- AI-generated content is often confidently incorrect, leading to the spread of inaccurate or misleading information.
-- We provide authorship credit for submissions, and to submit AI-generated work under one's own name would be a violation of our plagiarism policy.
-- Docs is an educational space for people to learn how to write effective technical documentation. Using generative AI, at this point, negatively impacts that desired learning goal.
-
 ## How do we update a PR branch?
 
 To keep your PR branch up to date, navigate to the branch on your fork. Then press `Fetch upstream` and `Fetch and merge`.
@@ -158,6 +150,60 @@ git rebase upstream main
 git push
 ```
 
+## Can I use AI tools when contributing?
+
+Yes! You can use AI tools to help create our Docs entries. [Codecademy Docs](https://github.com/Codecademy/docs) is an open-source project designed to help you learn how to contribute to open source, collaborate with the community, and use GitHub. It’s not meant to test whether you can write perfect technical content on your own.
+
+AI can assist you with drafting, rewriting, or structuring content. However, you are responsible for ensuring your work meets Codecademy’s quality and [style standards](https://github.com/Codecademy/docs/blob/main/documentation/content-standards.md). AI is a tool to help you, but it doesn't replace the standards we expect.
+
+You're accountable for all AI-assisted content.
+
+You may use AI to generate drafts or refine your writing, but you must personally review and improve all AI-assisted content before submitting. Every entry must follow:
+
+- [The Docs entry template](https://github.com/Codecademy/docs/blob/main/documentation/term-entry-template.md)
+- [Our content standards](https://github.com/Codecademy/docs/blob/main/documentation/content-standards.md)
+- [Our style guidelines](https://github.com/Codecademy/docs/blob/main/documentation/style-guide.md)
+
+> **Note:** If we detect plagiarism in your entry, you will be banned from contributing to Docs.
+
+## What you need to verify
+
+Even if AI produced the initial version of the entry, you must ensure that:
+
+- The content is accurate, technically correct, and fact-checked.
+- All explanations are clear and aligned with Codecademy Docs writing style.
+- Code examples compile or run correctly when required.
+- The text is not plagiarized or copied from external sources.
+- The final entry sounds intentional, not generic, or filled with filler text.
+- The formatting follows the Docs template exactly.
+
+AI output often contains vague definitions, hallucinated details, or inconsistent explanations. You must correct and refine these issues before submitting a pull request.
+
+## Quality standards apply to all entries
+
+Regardless of how you created the content, every entry must:
+
+- Use original wording.
+- Include accurate definitions and examples.
+- Follow the required structure, headings, and formatting.
+- Maintain a simple, educational, and neutral tone.
+- Avoid unnecessary complexity or overly broad explanations.
+- Fit the scope of a Docs reference entry.
+
+> **Note:** If your submission doesn't meet these standards, we'll ask you to revise it.
+
+## What happens during review?
+
+Maintainers (Codecademy’s content team who reviews all contributions) may request edits on any AI-assisted entry if it:
+
+- Does not follow our template.
+- Contains unclear, generic, or contradictory information.
+- Includes mistakes or technical inaccuracies.
+- Appears copied.
+- Lacks the clarity expected from Docs entries.
+
+You're expected to respond to feedback and make the requested improvements within 1 week, or your PR will be closed due to inactivity.
+
 Remember, if you ever have any questions at all, we're always here to help in the [Codecademy Forums](https://community.codecademy.com/).
 
 If you find any bugs or errors in the content, feel free to file an issue [here](https://github.com/Codecademy/docs/issues/new?assignees=Name+here&labels=bug&template=bug_reports.yml&title=%5BBug%2FError%5D+Subject%3A+Entry+Name)! 🖖

bin/concept-of-the-week.txt

@@ -1 +1 @@
-content/kotlin/concepts/variables/variables.md
+content/uiux/concepts/convergent-thinking/convergent-thinking.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/numpy/concepts/ndarray/terms/byteswap/byteswap.md

@@ -0,0 +1,117 @@
+---
+Title: 'byteswap()'
+Description: 'Swaps the byte order of each element in a NumPy ndarray.'
+Subjects:
+  - 'Computer Science'
+  - 'Data Science'
+Tags:
+  - 'Array'
+  - 'Data'
+  - 'NumPy'
+CatalogContent:
+  - 'learn-python-3'
+  - 'paths/data-science'
+---
+
+The **`byteswap()`** method reverses the byte order of every element in a NumPy array. This is used when converting data between systems with different endianness (byte-ordering conventions). The operation either returns a new array or modifies the original one in place when `inplace=True`.
+
+## Syntax
+
+```pseudo
+ndarray.byteswap(inplace=False)
+```
+
+**Parameters:**
+
+- `inplace` (optional): When set to `True`, the byte order of the existing array is swapped in place. When `False`, a new array with swapped bytes is returned.
+
+**Return value:**
+
+Returns a new ndarray with swapped byte order, unless `inplace=True`, in which case the original array is modified and returned.
+
+## Example 1
+
+In this example, the array's byte order is swapped to convert the data into the opposite endianness:
+
+```py
+import numpy as np
+
+arr = np.array([1, 256, 1024], dtype=np.int32)
+
+print("Original array:")
+print(arr)
+print("Original dtype:", arr.dtype)
+
+swapped = arr.byteswap()
+
+print("\nAfter byteswap():")
+print(swapped)
+print("Swapped dtype:", swapped.dtype)
+```
+
+The output of this code is:
+
+```shell
+Original array:
+[   1  256 1024]
+Original dtype: int32
+
+After byteswap():
+[16777216    65536   262144]
+Swapped dtype: int32
+```
+
+## Example 2
+
+This example demonstrates `byteswap(inplace=True)` and shows how the original data is altered directly:
+
+```py
+import numpy as np
+
+arr = np.array([100, 200, 300], dtype=np.int32)
+
+print("Before inplace byteswap:", arr)
+
+arr.byteswap(inplace=True)
+
+print("After inplace byteswap:", arr)
+```
+
+The output of this code is:
+
+```shell
+Before inplace byteswap: [100 200 300]
+After inplace byteswap: [1677721600 -939524096  738263040]
+```
+
+## Codebyte Example
+
+Use the codebyte below to inspect how `byteswap()` affects a 2-D array and observe the internal memory representation change:
+
+```codebyte/python
+import numpy as np
+
+matrix = np.array([[1, 2], [3, 4]], dtype=np.int16)
+
+print("Original:")
+print(matrix)
+
+swapped = matrix.byteswap()
+
+print("\nByteswapped:")
+print(swapped)
+```
+
+## Frequently Asked Questions
+
+### 1. What is the function of byteswap() in Python?
+
+The `byteswap()` method reverses the byte order of every element in a NumPy array. It is commonly used when preparing data for systems with different endianness or when interpreting binary data from external sources.
+
+### 2. What are bytes and bytearrays in Python?
+
+A `bytes` object in Python is an immutable sequence of byte values, while a bytearray is a mutable version of the same concept. Both store raw binary data and are often used for file handling, networking, and low-level memory operations.
+
+### 3. How to shuffle a NumPy ndarray?
+
+A NumPy array can be shuffled using `np.random.shuffle()` for in-place row-wise shuffling or `np.random.permutation()` to return a shuffled copy. These functions randomize the order of elements while preserving the array’s structure.