Merge branch 'main' into docs/css-margin-inline

Author: mamtawardhani

bin/concept-of-the-week.txt

@@ -1 +1 @@
-content/git/concepts/checkout/checkout.md
+content/kotlin/concepts/interfaces/interfaces.md

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

@@ -0,0 +1,94 @@
+---
+Title: 'Log10()'
+Description: 'Returns the base-10 logarithm of a specified number.'
+Subjects:
+  - 'Computer Science'
+  - 'Web Development'
+Tags:
+  - 'Arithmetic'
+  - 'Functions'
+  - 'Math'
+  - 'Methods'
+CatalogContent:
+  - 'learn-c-sharp'
+  - 'paths/computer-science'
+---
+
+In C#, the **`Math.Log10()`** [method](https://www.codecademy.com/resources/docs/c-sharp/methods) calculates the base-10 logarithm of a given number. This logarithm represents the power to which 10 must be raised to obtain the input value. The method is defined in the `System` namespace.
+
+## Syntax
+
+```pseudo
+Math.Log10(number);
+```
+
+**Parameters:**
+
+- `number`: A `double` value whose base-10 logarithm is computed.
+
+**Return value:**
+
+Returns a `double` that represents the base-10 logarithm of `number`.
+
+Return values for different inputs:
+
+- If the input is a positive number, the method returns its base-10 logarithm.
+- If the input is `0`, the method returns `NegativeInfinity`.
+- If the input is a negative number, the method returns `NaN`.
+- If the input is `NaN`, the method returns `NaN`.
+- If the input is `PositiveInfinity`, the method returns `PositiveInfinity`.
+- If the input is `NegativeInfinity`, the method returns `NaN`.
+
+## Example
+
+The example below demonstrates the return values of `Math.Log10()` for different inputs:
+
+```cs
+using System;
+
+class Geeks {
+  public static void Main(String[] args) {
+    double a = 4.55;
+    double b = 0;
+    double c = -2.45;
+    double nan = Double.NaN;
+    double positiveInfinity = Double.PositiveInfinity;
+    double negativeInfinity = Double.NegativeInfinity;
+
+    Console.WriteLine(Math.Log10(a));
+    Console.WriteLine(Math.Log10(b));
+    Console.WriteLine(Math.Log10(c));
+    Console.WriteLine(Math.Log10(nan));
+    Console.WriteLine(Math.Log10(positiveInfinity));
+    Console.WriteLine(Math.Log10(negativeInfinity));
+  }
+}
+```
+
+The output of the code is:
+
+```shell
+0.658011396657112
+-Infinity
+NaN
+NaN
+Infinity
+NaN
+```
+
+## Codebyte Example
+
+This codebyte example calculates the base-10 logarithm of a given number and prints the result:
+
+```codebyte/csharp
+using System;
+
+class Program {
+  static void Main() {
+    double x = 10.0;
+    double result = Math.Log10(x);
+
+    Console.WriteLine($"The base-10 logarithm of {x} is {result}");
+  }
+}
+```

content/cpp/concepts/unordered-set/terms/count/count.md

@@ -0,0 +1,108 @@
+---
+Title: 'count()'
+Description: 'Returns the number of elements with a specific key in an unordered_set.'
+Subjects:
+  - 'Code Foundations'
+  - 'Computer Science'
+Tags:
+  - 'Methods'
+  - 'Sets'
+  - 'STL'
+CatalogContent:
+  - 'learn-c-plus-plus'
+  - 'paths/computer-science'
+---
+
+The **`count()`** [method](https://www.codecademy.com/resources/docs/cpp/methods) in C++ checks whether a given key exists in a `std::unordered_set`. Since this container stores only unique elements, `count()` will always return one of these two values:
+
+- `1`: If the element is found in the set.
+- `0`: If the element is not found in the set.
+
+This method is commonly used as a fast, _O(1)_ average time complexity way to check for element existence.
+
+## Syntax
+
+```pseudo
+unordered_set_name.count(key);
+```
+
+**Parameters:**
+
+- `key` (const Key&): The value of the element to search for. Must be of the same type as the elements stored in the `unordered_set`.
+
+**Return value:**
+
+Returns an integer. `1` if the element exists, `0` otherwise.
+
+## Example
+
+This example demonstrates using `count()` to check for the presence of elements within a set of [strings](https://www.codecademy.com/resources/docs/cpp/strings):
+
+```cpp
+#include <iostream>
+#include <string>
+#include <unordered_set>
+
+int main() {
+  std::unordered_set<std::string> inventory = {
+    "Sword",
+    "Shield",
+    "Potion"
+  };
+
+  std::cout << "Inventory contains:\n";
+  for (const auto& item : inventory) {
+    std::cout << "- " << item << "\n";
+  }
+
+  // Check for an existing element
+  if (inventory.count("Sword")) {
+    std::cout << "\n'Sword' is present (Count: " << inventory.count("Sword") << ").\n";
+  }
+
+  // Check for a missing element
+  if (inventory.count("Axe") == 0) {
+    std::cout << "'Axe' is not present (Count: " << inventory.count("Axe") << ").\n";
+  }
+
+  return 0;
+}
+```
+
+The output of the code is:
+
+```shell
+Inventory contains:
+- Potion
+- Shield
+- Sword
+
+'Sword' is present (Count: 1).
+'Axe' is not present (Count: 0).
+```
+
+## Codebyte Example
+
+Run the codebyte below to check for the presence of an item in a set of integers:
+
+```codebyte/cpp
+#include <iostream>
+#include <unordered_set>
+
+int main() {
+  std::unordered_set<int> unique_ids = {101, 205, 330};
+
+  int search_key = 205;
+  int missing_key = 400;
+
+  // Check the count for the element 205
+  std::cout << "Count for " << search_key << ": "
+            << unique_ids.count(search_key) << "\n";
+
+  // Check the count for the element 400
+  std::cout << "Count for " << missing_key << ": "
+            << unique_ids.count(missing_key) << "\n";
+
+  return 0;
+}
+```

content/pytorch/concepts/tensor-operations/terms/logical-xor/logical-xor.md

@@ -0,0 +1,103 @@
+---
+Title: '.logical_xor()'
+Description: 'Computes the element-wise logical XOR (Exclusive OR) of two input tensors.'
+Subjects:
+  - 'Computer Science'
+  - 'Data Science'
+Tags:
+  - 'Booleans'
+  - 'Functions'
+  - 'PyTorch'
+  - 'Tensor'
+CatalogContent:
+  - 'intro-to-py-torch-and-neural-networks'
+  - 'paths/data-science'
+---
+
+The **`.logical_xor()`** function in PyTorch computes the element-wise logical XOR (Exclusive OR) of two input [tensors](https://www.codecademy.com/resources/docs/pytorch/tensors). The resulting tensor contains Boolean (`True` or `False`) values.
+
+According to the XOR rule, an element is `True` only if exactly one of the corresponding inputs is truthy. Inputs are interpreted as Boolean values where non-zero means `True` and zero means `False`.
+
+## Syntax
+
+```pseudo
+torch.logical_xor(input, other, out)
+```
+
+**Parameters:**
+
+- `input`: A Boolean tensor (or a tensor that can be cast to Boolean).
+- `other`: A Boolean tensor of the same shape or broadcastable to `input`.
+- `out` (optional): A tensor for storing the result in-place.
+
+**Return value:**
+
+Returns a Boolean tensor where each element is `True` when exactly one of the corresponding elements in `input` and `other` is `True`.
+
+## Example 1
+
+This example shows the logical XOR operation applied to two 2×2 tensors:
+
+```py
+import torch
+
+# Tensor A:
+# [True, False]
+# [True, True]
+tensor_a = torch.tensor([[1, 0], [5, 10]])
+
+# Tensor B:
+# [True, True]
+# [False, True]
+tensor_b = torch.tensor([[2, 3], [0, 1]])
+
+# Compute logical XOR: A XOR B
+# -----------------------------
+# [1 XOR 2] -> True XOR True -> False
+# [0 XOR 3] -> False XOR True -> True
+# [5 XOR 0] -> True XOR False -> True
+# [10 XOR 1] -> True XOR True -> False
+result_tensor = torch.logical_xor(tensor_a, tensor_b)
+
+print("Tensor A:\n", tensor_a)
+print("\nTensor B:\n", tensor_b)
+print("\nA.logical_xor(B) Result (Boolean):\n", result_tensor)
+```
+
+The output of this code is:
+
+```shell
+Tensor A:
+ tensor([[ 1,  0],
+        [ 5, 10]])
+
+Tensor B:
+ tensor([[2, 3],
+        [0, 1]])
+
+A.logical_xor(B) Result (Boolean):
+ tensor([[False,  True],
+        [ True, False]])
+```
+
+## Example 2
+
+This example demonstrates XOR on two 1-D tensors so each result maps cleanly to a single pair of elements:
+
+```py
+import torch
+
+x = torch.tensor([1, 0, 10, 0])
+y = torch.tensor([0, 5, 0, 0])
+
+# Compute x XOR y
+xor_result = torch.logical_xor(x, y)
+
+print(xor_result)
+```
+
+The output of this code is:
+
+```shell
+tensor([ True,  True,  True, False])
+```