Merge branch 'main' into plot

Author: dakshdeepHERE

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;
+}
+```

content/javascript/concepts/strings/terms/lastIndexOf/lastIndexOf.md

@@ -0,0 +1,73 @@
+---
+Title: '.lastIndexOf()'
+Description: 'Returns the index of the last occurrence of a specified substring within a string, or -1 if the substring is not found.'
+Subjects:
+  - 'Computer Science'
+  - 'Web Development'
+Tags:
+  - 'Strings'
+  - 'Methods'
+  - 'JavaScript'
+CatalogContent:
+  - 'learn-javascript'
+  - 'paths/web-development'
+---
+
+The **`.lastIndexOf()`** method in JavaScript returns the position of the last occurrence of a specified substring within a [string](https://www.codecademy.com/resources/docs/javascript/strings). If the substring is not found, it returns `-1`. It performs a case-sensitive search and can take an optional starting position from which to begin the search backwards.
+
+## Syntax
+
+```pseudo
+string.lastIndexOf(searchValue, fromIndex)
+```
+
+**Parameters:**
+
+- `searchValue`: The substring to search for.
+- `fromIndex` (optional): The position to start searching backward from. Defaults to the string’s length.
+
+**Return value:**
+
+Returns an integer representing the index of the last occurrence of the specified substring within the string. If the substring isn’t found, it returns `-1`.
+
+## Example 1: Finding the Last Mention of a Name
+
+In this example, a chat message contains multiple mentions of a person’s name, and the method finds the last one:
+
+```js
+const message = 'Hey Sam, Sam, are you coming to the meeting, Sam?';
+const lastSam = message.lastIndexOf('Sam');
+console.log(lastSam);
+```
+
+The output of this code is:
+
+```shell
+45
+```
+
+## Example 2: Searching Backward from a Certain Point
+
+In this example, the search begins from a specific index to locate the previous occurrence of a keyword:
+
+```js
+const report = 'Error at line 23. Warning at line 45. Error again at line 78.';
+const prevError = report.lastIndexOf('Error', 40);
+console.log(prevError);
+```
+
+The output of this code is:
+
+```shell
+38
+```
+
+## Codebyte Example: Locating the Last Hashtag in a Social Media Caption
+
+In this example, a caption includes multiple hashtags, and the method identifies the position of the last one:
+
+```codebyte/javascript
+const caption = 'Just finished a 10k run! #fitness #running #motivation';
+const lastHashtag = caption.lastIndexOf('#');
+console.log(lastHashtag);
+```