Merge branch 'main' into edit-user-persona

Author: AnamolR

content/c-sharp/concepts/lists/lists.md

@@ -0,0 +1,96 @@
+---
+Title: 'Lists'
+Description: 'A List in C# is a dynamic data structure that stores multiple objects of a specified type.'
+Subjects:
+  - 'Computer Science'
+  - 'Code Foundations'
+  - 'Developer Tools'
+Tags:
+  - 'Data Structures'
+  - 'Lists'
+CatalogContent:
+  - 'learn-c-sharp'
+  - 'paths/computer-science'
+---
+
+A **`List`** in [C#](https://www.codecademy.com/resources/docs/c-sharp) is a dynamic [data structure](https://www.codecademy.com/resources/docs/general/data-structures) that stores multiple objects of a specified type. These objects can be accessed by their zero-based index. Unlike [arrays](https://www.codecademy.com/resources/docs/c-sharp/arrays). Lists can grow to accommodate a very large number of elements (up to about 2 billion), limited primarily by available system memory and the maximum value of an integer index."
+
+## Syntax
+
+> **Note:** Before creating a list, include the `System.Collections.Generic` namespace.
+
+There are two common ways to create a `List` in C#:
+
+```pseudo
+// Creating a List without any elements
+List<T> myList = new List<T>();
+```
+
+Or alternatively:
+
+```pseudo
+// Creating a List with three elements
+List<T> myList = new List<T> { element1, element2, element3 };
+```
+
+**Parameters:**
+
+- `T`: Represents any data type.
+- `element`: Any object or variable of type `T`.
+
+## Example: Creating and Accessing a List
+
+In this example, a list is created, numbers are added, and elements are accessed by their index:
+
+```cs
+using System;
+using System.Collections.Generic;
+
+class Program
+{
+  static void Main()
+  {
+    // Create a list of integers
+    List<int> numbers = new List<int>();
+
+    // Add elements to the list
+    numbers.Add(10);
+    numbers.Add(20);
+    numbers.Add(30);
+
+    // Access elements by index
+    Console.WriteLine(numbers[0]);
+    Console.WriteLine(numbers[1]);
+    Console.WriteLine(numbers[2]);
+  }
+}
+```
+
+The output of this code is:
+
+```shell
+10
+20
+30
+```
+
+## Codebyte Example: Printing elements in a List
+
+This example creates a new `List` that stores three numbers. Since each element has an index, we can print each element in the `numbers` list by its index:
+
+```codebyte/csharp
+using System;
+using System.Collections.Generic;
+
+public class Test
+{
+  public static void Main()
+  {
+    List<int> numbers = new List<int> { 2, 5, 10 };
+
+    Console.WriteLine(numbers[0]);
+    Console.WriteLine(numbers[1]);
+    Console.WriteLine(numbers[2]);
+  }
+}
+```

content/java/concepts/strings/terms/equals/equals.md

@@ -36,8 +36,8 @@ public class MyClass {
 
     // With string objects
     String myFavoriteLanguage = "Java";
-    String codeNinjasFavoriteLangauge = "Java";
-    System.out.println(myFavoriteLanguage.equals(codeNinjasFavoriteLangauge));
+    String codeNinjasFavoriteLanguage = "Java";
+    System.out.println(myFavoriteLanguage.equals(codeNinjasFavoriteLanguage));
   }
 }
 ```

content/pytorch/concepts/tensor-operations/terms/floor-divide/floor-divide.md

@@ -0,0 +1,55 @@
+---
+Title: '.floor_divide()'
+Description: 'Computes element-wise division of tensors (or tensor and scalar) and applies floor rounding.'
+Subjects:
+  - 'Computer Science'
+  - 'Machine Learning'
+Tags:
+  - 'Functions'
+  - 'Machine Learning'
+  - 'Python'
+  - 'Tensor'
+CatalogContent:
+  - 'intro-to-py-torch-and-neural-networks'
+  - 'paths/computer-science'
+---
+
+In PyTorch, the **`.floor_divide()`** function divides the `input` by other element-wise and rounds each quotient down to the nearest integer, returning the floored result as a [tensor](https://www.codecademy.com/resources/docs/pytorch/tensors). It supports broadcasting, type promotion, and both integer and floating-point operands. The operation can be expressed as:
+
+$$\text{out}_i = \text{floor}(\frac{\text{input}_i}{\text{other}_i})$$
+
+## Syntax
+
+```pseudo
+torch.floor_divide(input, other, *, out=None) → Tensor
+```
+
+**Parameters:**
+
+- `input`: The input tensor(dividend).
+- `other`: Tensor or Number(divisor).
+- `out` (Optional): A tensor to store the output. If provided, the result is written to this tensor.
+
+**Return value:**
+
+It returns a new tensor of the same shape as the `input`, containing the result of element-wise division and rounds the result of the division down to the nearest integer.
+
+## Example
+
+In this example, we use `floor_divide()` to perform divison of two tensors `x` and `y` :
+
+```py
+import torch
+
+x = torch.tensor([4.0, 3.0])
+
+y = torch.tensor([2.0, 2.0])
+
+print(torch.floor_divide(x, y))
+```
+
+The output of this code is:
+
+```shell
+tensor([2., 1.])
+```