Merge branch 'main' into edit-csharp-arrays

Author: mamtawardhani

bin/concept-of-the-week.txt

@@ -1 +1 @@
-content/git/concepts/checkout/checkout.md
+content/swift/concepts/ranges/ranges.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/math-functions/terms/fpclassify/fpclassify.md

@@ -0,0 +1,125 @@
+---
+Title: 'fpclassify()'
+Description: 'Classifies a floating-point value into categories such as zero, normal, subnormal, infinite, or NaN.'
+Subjects:
+  - 'Computer Science'
+  - 'Data Science'
+Tags:
+  - 'Classification'
+  - 'Functions'
+  - 'Math'
+CatalogContent:
+  - 'learn-c-plus-plus'
+  - 'paths/computer-science'
+---
+
+The **`fpclassify()`** [function](https://www.codecademy.com/resources/docs/cpp/functions) in C++ returns an integer value indicating the classification of a floating-point number. It categorizes values as normal, subnormal, zero, infinite, or NaN (Not-a-Number). The function is available through the `<cmath>` header.
+
+## Syntax
+
+```pseudo
+fpclassify(x)
+```
+
+**Parameters:**
+
+- `x`: A floating-point value (can be `float`, `double`, or `long double`).
+
+**Return value:**
+
+The `fpclassify()` function returns one of the following integer constants:
+
+- `FP_INFINITE`: The value is positive or negative infinity.
+- `FP_NAN`: The value is NaN (Not-a-Number).
+- `FP_ZERO`: The value is zero.
+- `FP_SUBNORMAL`: The value is a subnormal (denormalized) number.
+- `FP_NORMAL`: The value is a normal finite non-zero number.
+
+## Example
+
+The following example demonstrates various classifications using `fpclassify()`:
+
+```cpp
+#include <iostream>
+#include <cmath>
+
+using namespace std;
+
+int main() {
+  double normal = 1.5;
+  double zero = 0.0;
+  double inf = INFINITY;
+  double nan = NAN;
+
+  cout << "Classification of " << normal << ": ";
+  if (fpclassify(normal) == FP_NORMAL) {
+    cout << "Normal" << endl;
+  }
+
+  cout << "Classification of " << zero << ": ";
+  if (fpclassify(zero) == FP_ZERO) {
+    cout << "Zero" << endl;
+  }
+
+  cout << "Classification of inf: ";
+  if (fpclassify(inf) == FP_INFINITE) {
+    cout << "Infinite" << endl;
+  }
+
+  cout << "Classification of nan: ";
+  if (fpclassify(nan) == FP_NAN) {
+    cout << "NaN" << endl;
+  }
+
+  return 0;
+}
+```
+
+The output of this code is:
+
+```shell
+Classification of 1.5: Normal
+Classification of 0: Zero
+Classification of inf: Infinite
+Classification of nan: NaN
+```
+
+## Codebyte Example
+
+The following runnable example shows how to use `fpclassify()` with different values:
+
+```codebyte/cpp
+#include <iostream>
+#include <cmath>
+
+using namespace std;
+
+int main() {
+  double values[] = {1.0, 0.0, INFINITY, NAN, -5.5};
+
+  for (double val : values) {
+    cout << "fpclassify(" << val << ") = ";
+
+    switch(fpclassify(val)) {
+      case FP_INFINITE:
+        cout << "Infinite";
+        break;
+      case FP_NAN:
+        cout << "NaN";
+        break;
+      case FP_ZERO:
+        cout << "Zero";
+        break;
+      case FP_SUBNORMAL:
+        cout << "Subnormal";
+        break;
+      case FP_NORMAL:
+        cout << "Normal";
+        break;
+    }
+    cout << endl;
+  }
+
+  return 0;
+}
+```

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