Merge branch 'main' into cpp-math-functions-isgreaterequal

Author: CadilheP

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

content/cpp/concepts/queues/terms/emplace/emplace.md

@@ -0,0 +1,142 @@
+---
+Title: 'emplace()'
+Description: 'Constructs a new element at the end of the queue in-place using forwarded arguments.'
+Subjects:
+  - 'Code Foundations'
+  - 'Computer Science'
+Tags:
+  - 'Containers'
+  - 'Methods'
+  - 'Queues'
+CatalogContent:
+  - 'learn-c-plus-plus'
+  - 'paths/computer-science'
+---
+
+The **`emplace()`** method of the `std::queue<T,Container>` container adaptor constructs a new element directly in the underlying container at the back of the queue, forwarding the provided arguments to the constructor of `T`. Because the object is constructed in place, this can improve performance for types with expensive copy or move operations.
+
+## Syntax
+
+```pseudo
+queue.emplace(args...)
+```
+
+**Parameters:**
+
+- `args...` (variadic template parameters): Arguments forwarded to construct the new element of type `T`.
+
+**Return value:**
+
+Since C++17: A reference to the inserted element (the value returned by the underlying container's `emplace_back` method).
+
+## Example 1: Enqueueing log entries into a queue
+
+In this example, log messages are constructed in place and enqueued for later processing:
+
+```cpp
+#include <iostream>
+#include <queue>
+#include <string>
+
+struct LogEntry {
+  std::string level;
+  std::string message;
+  LogEntry(std::string lvl, std::string msg)
+    : level(std::move(lvl)), message(std::move(msg)) {}
+};
+
+int main(){
+  std::queue<LogEntry> logs;
+  logs.emplace("INFO", "Application started");
+  logs.emplace("WARN", "Low disk space");
+  logs.emplace("ERROR", "Out of memory");
+
+  while(!logs.empty()){
+    const auto& entry = logs.front();
+    std::cout << "[" << entry.level << "] " << entry.message << "\n";
+    logs.pop();
+  }
+}
+```
+
+The output of this code is:
+
+```shell
+[INFO] Application started
+[WARN] Low disk space
+[ERROR] Out of memory
+```
+
+## Example 2: Constructing tasks in a task queue
+
+In this example, tasks with multiple constructor parameters are constructed directly inside the queue:
+
+```cpp
+#include <iostream>
+#include <queue>
+#include <functional>
+
+struct Task {
+  int id;
+  std::string description;
+  Task(int i, std::string desc)
+    : id(i), description(std::move(desc)) {}
+  void run() const { std::cout << "Running task #" << id << ": " << description << "\n"; }
+};
+
+int main(){
+  std::queue<Task> taskQueue;
+  taskQueue.emplace(1, "Load configuration");
+  taskQueue.emplace(2, "Initialize modules");
+  taskQueue.emplace(3, "Start services");
+
+  while(!taskQueue.empty()){
+    taskQueue.front().run();
+    taskQueue.pop();
+  }
+}
+```
+
+The output of this code is:
+
+```shell
+Running task #1: Load configuration
+Running task #2: Initialize modules
+Running task #3: Start services
+```
+
+## Codebyte Example: Buffering sensor data with emplace
+
+In this example, sensor readings are constructed and enqueued as soon as they arrive, minimizing overhead:
+
+```codebyte/cpp
+#include <iostream>
+#include <queue>
+#include <tuple>
+
+struct SensorData {
+  int sensorId;
+  double value;
+  long timestamp;
+  SensorData(int id, double val, long ts)
+    : sensorId(id), value(val), timestamp(ts) {}
+  void print() const {
+    std::cout << "Sensor#" << sensorId
+              << " value=" << value
+              << " time=" << timestamp << "\n";
+  }
+};
+
+int main(){
+  std::queue<SensorData> buffer;
+  buffer.emplace(101, 23.5, 1617181920L);
+  buffer.emplace(102, 19.8, 1617181930L);
+
+  while(!buffer.empty()){
+    buffer.front().print();
+    buffer.pop();
+  }
+
+  return 0;
+}
+```