Merge branch 'main' into logical_or()

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/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.

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

@@ -0,0 +1,125 @@
+---
+Title: 'size()'
+Description: 'Returns the number of elements in a deque container.'
+Subjects:
+  - 'Computer Science'
+  - 'Game Development'
+Tags:
+  - 'Containers'
+  - 'Deques'
+  - 'Methods'
+  - 'STL'
+CatalogContent:
+  - 'learn-c-plus-plus'
+  - 'paths/computer-science'
+---
+
+The **`size()`** function returns the number of elements currently stored in a [`std::deque`](https://www.codecademy.com/resources/docs/cpp/deque) container. It has constant time complexity (`O(1)`) and is marked noexcept since C++ 11.
+
+## Syntax
+
+```pseudo
+deque_object.size();
+```
+
+**Parameters:**
+
+This function does not take any parameters.
+
+**Return value:**
+
+Returns a value of type `size_type` (an unsigned integral type) representing the number of elements in the deque.
+
+## Example 1
+
+In this example, the size method is used to check the element count of an initially empty deque, then after [`push_back`](https://www.codecademy.com/resources/docs/cpp/deque/push-back) operations:
+
+```cpp
+#include <deque>
+#include <iostream>
+
+int main() {
+  std::deque<int> d;
+  std::cout << "Initial size: " << d.size() << "\n";
+
+  for (int i = 0; i < 5; ++i) {
+    d.push_back(i);
+  }
+  std::cout << "Size after push_back 5 elements: " << d.size() << "\n";
+
+  return 0;
+}
+```
+
+The output of this code is:
+
+```shell
+Initial size: 0
+Size after push_back 5 elements: 5
+```
+
+## Example 2
+
+In this example, the size method is used after insert and pop operations to illustrate dynamic changes in element count:
+
+```cpp
+#include <deque>
+#include <iostream>
+
+int main() {
+  std::deque<int> d = {1, 2, 3};
+  std::cout << "Initial size: " << d.size() << "\n";
+
+  d.pop_front();
+  d.pop_back();
+  std::cout << "Size after two pops: " << d.size() << "\n";
+
+  d.insert(d.begin(), 10);
+  std::cout << "Size after one insert at front: " << d.size() << "\n";
+
+  return 0;
+}
+```
+
+The output of this code is:
+
+```shell
+Initial size: 3
+Size after two pops: 1
+Size after one insert at front: 2
+```
+
+## Codebyte Example
+
+In this example, the `size()` method is repeatedly checked in a loop until the deque becomes empty:
+
+```codebyte/cpp
+#include <iostream>
+#include <deque>
+
+int main() {
+  std::deque<char> letters = {'A', 'B', 'C', 'D', 'E'};
+
+  while (!letters.empty()) {
+    std::cout << "Current size: " << letters.size() << " front element: " << letters.front() << "\n";
+    letters.pop_front();
+  }
+
+  std::cout << "Final size after emptying: " << letters.size() << "\n";
+  return 0;
+}
+```
+
+## Frequently Asked Questions
+
+### 1. What does `size()` do in C++?
+
+The `size()` function in C++ returns the number of elements present in a container, such as a `std::deque`, `std::vector`, or `std::string`. It gives the current length of the container in constant time (`O(1)`) without modifying it.
+
+### 2. What is a deque function in C++?
+
+A deque (double-ended queue) in C++ is a Standard Template Library (STL) container that allows insertion and deletion of elements from both the front and back efficiently.
+
+### 3. How to get the size of a deque in C++?
+
+You can get the number of elements in a deque using the `size()` member function.