Merge branch 'main' into byteswap

Author: Sriparno08

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/strings/strings.md
+content/kotlin/concepts/classes/classes.md

content/c-sharp/concepts/math-functions/terms/acosh/acosh.md

@@ -0,0 +1,80 @@
+---
+Title: 'Acosh()'
+Description: 'Returns the inverse hyperbolic cosine of a specified number.'
+Subjects:
+  - 'Computer Science'
+  - 'Web Development'
+Tags:
+  - 'Functions'
+  - 'Math'
+  - 'Methods'
+  - 'Numbers'
+CatalogContent:
+  - 'learn-c-sharp'
+  - 'paths/computer-science'
+---
+
+The **`Math.Acosh()`** method returns the inverse hyperbolic cosine (also known as hyperbolic arccosine) of a specified number. It computes the value whose hyperbolic cosine equals the given number.
+
+## Syntax
+
+```pseudo
+Math.Acosh(number);
+```
+
+**Parameters:**
+
+- `number`: A double-precision floating-point value greater than or equal to `1`, for which to compute the inverse hyperbolic cosine.
+
+**Return value:**
+
+- The inverse hyperbolic cosine of the specified number in radians as a `double`.
+- `NaN` if the input is less than `1` or `NaN`.
+
+## Example: Basic Usage of `Math.Acosh()`
+
+This example calculates the inverse hyperbolic cosine of a number using `Math.Acosh()` and displays the result in radians:
+
+```cs
+using System;
+
+public class Example
+{
+  public static void Main()
+  {
+    double number = 1.5;
+    double result = Math.Acosh(number);
+    Console.WriteLine($"Math.Acosh({number}) = {result} radians");
+  }
+}
+```
+
+This example outputs the following:
+
+```shell
+Math.Acosh(1.5) = 0.9624236501192069 radians
+```
+
+## Codebyte Example
+
+In this example, the `Math.Acosh()` method is used to calculate the inverse hyperbolic cosine of a specified number in radians and degrees:
+
+```codebyte/csharp
+using System;
+
+public class Example {
+  public static void Main() {
+    double number = 100.0;
+
+    // Calculate Acosh in radians
+    double resultRadians = Math.Acosh(number);
+
+    // Convert radians to degrees
+    double resultDegrees = resultRadians * (180.0 / Math.PI);
+
+    // Display results
+    Console.WriteLine($"Math.Acosh({number}) = {resultRadians} radians");
+    Console.WriteLine($"Math.Acosh({number}) = {resultDegrees} degrees");
+  }
+}
+```

content/c-sharp/concepts/math-functions/terms/clamp/clamp.md

@@ -0,0 +1,93 @@
+---
+Title: 'Clamp()'
+Description: 'Restricts a value to lie within a specified minimum and maximum range.'
+Subjects:
+  - 'Code Foundations'
+  - 'Computer Science'
+Tags:
+  - 'Arithmetic'
+  - 'Method'
+  - 'Numbers'
+CatalogContent:
+  - 'learn-c-sharp'
+  - 'paths/computer-science'
+---
+
+The **`Math.Clamp()`** is a static method that returns the value clamped to the inclusive range of min and max.
+
+> **Note:** The static method `Math.Clamp()` was introduced in .NET Core 2.0.
+
+## Syntax
+
+```pseudo
+Math.Clamp(value, min, max);
+```
+
+**Parameters:**
+
+- `value`: The value to be clamped.
+- `min`: The lower bound of the result.
+- `max`: The upper bound of the result.
+
+**Return value:**
+
+Returns the value clamped to the inclusive range of min and max.
+
+> **Note:** If value is less than `min`, it returns `min`; if greater than `max`, it returns `max`; otherwise, it returns `value`.
+
+## Example
+
+The following example demonstrates the `Math.Clamp()` method and writes the result to the console.
+
+```cs
+using System;
+
+class Program
+{
+  static void Main()
+  {
+    int min = 2;
+    int max = 8;
+
+    int result = Math.Clamp(10, min, max);
+    Console.WriteLine(result);
+  }
+}
+```
+
+The example will result in the following output:
+
+```shell
+8
+```
+
+## Codebyte Example
+
+In this example, a random list of decimal numbers is generated, and `Math.Clamp()` ensures that all stored values stay within the defined range:
+
+```codebyte/csharp
+using System;
+
+class Example
+{
+  static void Main()
+  {
+    Random random = new Random();
+    double[] nums = new double[10];
+    int min = 1;
+    int max = 50;
+
+    for (int i = 0; i < nums.Length; i++)
+    {
+      double range = random.NextDouble() * 70 - 10; // -10 to 60
+      double limit = Math.Clamp(range, min, max);
+      nums[i] = limit;
+    }
+
+    foreach (double num in nums)
+    {
+      Console.WriteLine(num);
+    }
+  }
+}
+```

content/cpp/concepts/deque/terms/at/at.md

@@ -0,0 +1,130 @@
+---
+Title: '.at()'
+Description: 'Accesses an element at a specified index in a deque with bounds checking.'
+Subjects:
+  - 'Computer Science'
+  - 'Game Development'
+Tags:
+  - 'Containers'
+  - 'Deques'
+  - 'Methods'
+  - 'STL'
+CatalogContent:
+  - 'learn-c-plus-plus'
+  - 'paths/computer-science'
+---
+
+The C++ **`.at()`** [function](https://www.codecademy.com/resources/docs/cpp/functions) accesses the element at a given index in a deque while performing bounds checking. If the index is out of range, the function throws an `std::out_of_range` [exception](https://www.codecademy.com/resources/docs/cpp/exceptions). This makes it a safer alternative to the subscript operator `[]`, which offers no safety checks.
+
+## Syntax
+
+```pseudo
+deque.at(pos)
+```
+
+**Parameters:**
+
+- `pos`: A zero-based index of the element to access. Must be within the valid range of the deque.
+
+**Return value:**
+
+Returns a reference to the element at the given position.
+
+**Exceptions:**
+
+Throws `std::out_of_range` if `pos` is invalid.
+
+## Example 1: Accessing Elements Safely
+
+In this example, `.at()` retrieves elements from valid positions in the deque:
+
+```cpp
+#include <iostream>
+#include <deque>
+using namespace std;
+
+int main() {
+  deque<int> numbers = {10, 20, 30, 40};
+
+  cout << "Element at index 2: " << numbers.at(2) << endl;
+  cout << "Element at index 0: " << numbers.at(0) << endl;
+
+  return 0;
+}
+```
+
+The output of this code is:
+
+```shell
+Element at index 2: 30
+Element at index 0: 10
+```
+
+The `.at()` function returns elements at positions 2 and 0 with built-in bounds checking.
+
+## Example 2: Handling Out-of-Range Access
+
+In this example, accessing index 5 triggers an exception because the index is outside the deque's valid range:
+
+```cpp
+#include <iostream>
+#include <deque>
+using namespace std;
+
+int main() {
+  deque<string> names = {"Ava", "Mira", "Leo"};
+
+  try {
+    cout << names.at(5) << endl;
+  } catch (const out_of_range& e) {
+    cout << "Error: " << e.what() << endl;
+  }
+
+  return 0;
+}
+```
+
+The output of this code is:
+
+```shell
+Error: deque::_M_range_check: __n (which is 5)>= this->size() (which is 3)
+```
+
+## Codebyte Example
+
+This example demonstrates safe element access and shows how `.at()` behaves when an invalid index is used:
+
+```codebyte/cpp
+#include <iostream>
+#include <deque>
+using namespace std;
+
+int main() {
+  deque<char> letters = {'A', 'B', 'C', 'D'};
+
+  cout << "First element: " << letters.at(0) << endl;
+  cout << "Third element: " << letters.at(2) << endl;
+
+  try {
+    cout << letters.at(10) << endl;
+  } catch (const out_of_range& e) {
+    cout << "Caught exception: " << e.what() << endl;
+  }
+
+  return 0;
+}
+```
+
+## Frequently Asked Questions
+
+### 1. What is the use of deque in C++?
+
+A deque (double-ended queue) stores elements in a dynamic sequence where insertions and deletions at both the front and back are efficient. It supports random access like a vector but provides faster operations at the beginning of the structure.
+
+### 2. What is a std::deque?
+
+`std::deque` is a standard container that provides a dynamic array-like structure with fast operations at both ends. It is implemented as segmented memory blocks, which allows it to grow without relocating all elements like a vector.
+
+### 3. How to check if deque is empty in C++?
+
+A deque can be checked for emptiness using the `.empty()` method, which returns `true` if it contains no elements and `false` otherwise. This check is constant time and works for all standard containers.