Merge branch 'main' into roundsuffix_entry

Author: mamtawardhani

content/ai/concepts/search-algorithms/terms/beam-search/beam-search.md

@@ -2,19 +2,20 @@
 Title: 'BEAM Search'
 Description: 'A graph searching algorithm that is a variant of breadth-first search.'
 Subjects:
-  - 'Data Science'
   - 'AI'
+  - 'Data Science'
 Tags:
-  - 'Search Algorithms'
   - 'AI'
+  - 'Algorithms'
+  - 'Search Algorithms'
 CatalogContent:
   - 'learn-python-3'
-  - 'paths/machine-learning-ai-engineering-foundations'
+  - 'paths/computer-science'
 ---
 
 **BEAM Search**, a variant of [breadth-first Search](https://www.codecademy.com/resources/docs/ai/search-algorithms/breadth-first-search), is an algorithm that searches a weighted graph for an optimal path from some start node **S** to some goal node **G**. The difference between BEAM search and breadth-first search is that at every level of the search tree, only the top _β_ candidates are chosen for further exploration. Here, β is known as the _beam width_. The reasoning behind this is that a path from **S** to **G** is likely to pass through some top number of most promising nodes. This leads to an algorithm that is fast and memory-efficient because it can disregard many nodes that may appear to be too far from the goal. This, however, sometimes causes the algorithm to overlook a potential shortest path because a candidate node is greater than the beam width. This renders the algorithm as _incomplete_, meaning that finding the shortest path is not guaranteed. Since the algorithm can find a reasonably short path, trading completeness for efficiency is accepted. Much like [A\* search](https://www.codecademy.com/resources/docs/ai/search-algorithms/a-star-search) and [best-first search](https://www.codecademy.com/resources/docs/ai/search-algorithms/best-first-search), an evaluation function is used to evaluate the candidacy of nodes for further exploration.
 
-## The Algorithm
+## How the Beam Search Algorithm Works
 
 Similar to A\* search, the algorithm uses an **open list** and a **closed list** for the exploration of nodes. In this algorithm, the open list is an ordinary queue. The algorithm begins with a start node **S**, which also serves as the root node for the search tree.
 
@@ -58,10 +59,67 @@ It is in this step that node **G** has been found:
 Trace the path from **S** to **G**:
 ![Final-path](https://raw.githubusercontent.com/Codecademy/docs/main/media/BEAM-Search-final-path.png)
 
-## Advantages and Disadvantages
+## Pseudocode for Beam Search Algorithm
+
+```plaintext
+function BEAM_SEARCH(start_node, goal_test, beam_width, max_depth):
+    current_level ← [start_node]
+    depth ← 0
+
+    while current_level is not empty AND depth < max_depth:
+        all_successors ← []
+
+        // Generate all successors from current level
+        for each node in current_level:
+            if goal_test(node):
+                return SUCCESS (node)
+
+            successors ← get_successors(node)
+            for each successor in successors:
+                successor.score ← evaluation_function(successor)
+                all_successors.append(successor)
+
+        if all_successors is empty:
+            return FAILURE
+
+        // Sort all successors by their scores (best first)
+        sorted_successors ← sort(all_successors, by=score, descending=True)
+
+        // Keep only top beam_width candidates for next level
+        current_level ← sorted_successors[0 : beam_width]
+        depth ← depth + 1
+
+    // Check final level for goal
+    for each node in current_level:
+        if goal_test(node):
+            return SUCCESS (node)
+
+    return FAILURE
+```
+
+## Advantages and Disadvantages of Beam Search
 
 As stated before, the advantage of BEAM search is that it is efficient both in time and memory. The disadvantage can be seen from the example in that a possible shortest path from **S** to **G** was overlooked. This can be somewhat corrected by varying the beam width to include more nodes. This, however, would reduce the efficiency of the algorithm. Selecting the optimal beam width is problem-specific and usually requires further insight into the problem.
 
 ## Applications of BEAM Search
 
 The BEAM search algorithm is commonly used in natural language processing and machine translation. An encoder is used to process the text from the source language and BEAM search selects the most probable words (the beam width) in the target language. The evaluation function in this context is the conditional probability of a word in the target language.
+
+## Frequently Asked Questions
+
+### 1. Is ChatGPT using beam search?
+
+No, ChatGPT (and most large language models from OpenAI) doesn't use beam search during inference. It uses sampling-based decoding methods like top-k sampling, top-p (nucleus) sampling, or temperature-controlled sampling to generate text.
+
+### 2. Where is beam search used?
+
+Beam search is widely used in natural language processing (NLP) tasks where sequential predictions are needed:
+
+- Machine translation (e.g., translating English to French)
+- Speech recognition
+- Text generation (in some models)
+- Optical character recognition (OCR)
+
+### 3. What are the benefits of beam search?
+
+Beam search is faster and more memory-efficient than exhaustive search. It explores only the most promising paths, giving better results than greedy search while still being customizable through the beam width. However, it might miss the optimal path.

content/c-sharp/concepts/strings/terms/substring/substring.md

@@ -1,95 +1,156 @@
 ---
 Title: '.Substring()'
-Description: 'Returns the substring of a string instance starting at a given index.'
+Description: 'Extracts a portion of a string starting from a specified index position.'
 Subjects:
-  - 'Code Foundations'
   - 'Computer Science'
+  - 'Web Development'
 Tags:
+  - 'Data Types'
   - 'Methods'
   - 'Strings'
 CatalogContent:
   - 'learn-c-sharp'
   - 'paths/computer-science'
 ---
 
-The **`.Substring()`** method is a string method that returns a substring of a string starting at the specified index. It will return all characters from that index to the end unless a maximum length is specified. If the starting index equals the string length, it returns an empty string (`""`). If the index is greater than the string length, it throws an `ArgumentOutOfRangeException`.
+The C# **`.Substring()`** method is a built-in [string](https://www.codecademy.com/resources/docs/c-sharp/strings) method that extracts a portion of a string starting from a specified index position. It returns a new string containing the characters from the starting position to either the end of the string or for a specified length, without modifying the original string.
 
-## Syntax
+## Syntax of C# `.Substring()`
 
 ```pseudo
-.Substring(int startIndex)
+public string Substring(int startIndex)
+public string Substring(int startIndex, int length)
 ```
 
-Or, alternatively:
+**Parameters:**
 
-```pseudo
-.Substring(int startIndex, int length)
-```
+- `startIndex`: The zero-based starting position from where the substring begins. The type is `System.Int32`.
+- `length` (optional): The number of characters to include in the substring. The type is `System.Int32`.
+
+**Return value:**
+
+Both methods return a new string (`System.String`) containing the extracted substring.
 
-- `startIndex`: The index from where the substring starts.
-- `Length` (Optional): The number of characters to include in the substring..
+**Exceptions:**
 
-## Example
+The method throws `ArgumentOutOfRangeException` if:
 
-In this example, `.Substring()` is used to return the substring of "Codecademy" starting at index `4` and includes all characters from that position to the end of the string:
+- `startIndex` is less than zero or greater than the length of the string
+- `length` is less than zero
+- `startIndex` plus `length` indicates a position not within the current string
+
+## Example 1: Basic Usage of `.Substring()`
+
+This example demonstrates how to use the `.Substring()` method with a single parameter to extract characters from a specific position to the end of the string:
 
 ```cs
 using System;
 
 public class Program
 {
-    public static void Main()
-    {
-        string str = "Codecademy";
-        Console.WriteLine(str.Substring(4));
-    }
+  public static void Main()
+  {
+    string text = "Hello World";
+
+    // Extract substring from index 6 to the end
+    string result = text.Substring(6);
+
+    Console.WriteLine($"Original: {text}");
+    Console.WriteLine($"Substring from index 6: {result}");
+  }
 }
 ```
 
-The above example results in the following output:
+The output of this example will be:
 
 ```shell
-cademy
+Original: Hello World
+Substring from index 6: World
 ```
 
-## Example 2
+This example extracts all characters starting from index 6 (the letter 'W') to the end of the string.
+
+## Example 2: Extract Characters with Length Using `.Substring()`
 
-In this example, `.Substring()` is used with the optional `length` parameter to return a substring of 6 characters starting from index `2` of the string `"Codecademy"`.
+This example shows how to use the `.Substring()` method with both parameters to extract a specific number of characters:
 
 ```cs
 using System;
 
 public class Program
 {
-    public static void Main()
-    {
-        string str = "Codecademy";
-        Console.WriteLine(str.Substring(2, 6));
-    }
+ public static void Main()
+  {
+    string email = "user@example.com";
+
+    // Extract username (characters before @)
+    int atIndex = email.IndexOf('@');
+    string username = email.Substring(0, atIndex);
+
+    // Extract domain (characters after @)
+    string domain = email.Substring(atIndex + 1);
+
+    Console.WriteLine($"Email: {email}");
+    Console.WriteLine($"Username: {username}");
+    Console.WriteLine($"Domain: {domain}");
+  }
 }
 ```
 
-The above code generates the following output:
+The output of this code will be:
 
-````shell
-decade
+```shell
+Email: user@example.com
+Username: user
+Domain: example.com
+```
+
+The above example demonstrates extracting the username from an email address and getting a portion of the domain.
 
-## Codebyte Example
+## Codebyte Example: Using C# `.Substring()` for File Path Processing
 
-The below code demonstrates how to use the Substring method:
+This example shows a real-world scenario where `.Substring()` is used to process file paths and extract file information:
 
 ```codebyte/csharp
 using System;
 
-public class Example
+public class Program
 {
-    public static void Main(string[] args)
-    {
-        string Name1 = "Brad";
-        string Name2 = "Angelina";
-
-        Console.WriteLine(Name1.Substring(1));
-        Console.WriteLine(Name2.Substring(1));
-    }
+  public static void Main()
+  {
+    string filePath = "C:\\Documents\\Projects\\MyApplication.exe";
+
+    // Extract filename with extension
+    int lastSlash = filePath.LastIndexOf('\\');
+    string fileName = filePath.Substring(lastSlash + 1);
+
+    // Extract file extension
+    int dotIndex = fileName.LastIndexOf('.');
+    string extension = fileName.Substring(dotIndex + 1);
+
+    // Extract filename without extension
+    string nameOnly = fileName.Substring(0, dotIndex);
+
+    Console.WriteLine($"Full path: {filePath}");
+    Console.WriteLine($"Filename: {fileName}");
+    Console.WriteLine($"Extension: {extension}");
+    Console.WriteLine($"Name only: {nameOnly}");
+  }
 }
-````
+```
+
+This example processes a file path to extract different components.
+
+## Frequently Asked Questions
+
+### 1. What happens if I pass a negative index to `.Substring()`?
+
+The method will throw an `ArgumentOutOfRangeException` if the `startIndex` is negative or greater than the string length.
+
+### 2. Can `.Substring()` modify the original string?
+
+No, `.Substring()` returns a new string and does not modify the original string, as strings are immutable in C#.
+
+### 3. What's the difference between `.Substring()` and `Span<char>`?
+
+`.Substring()` creates a new string object, while `Span<char>` provides a memory-efficient way to work with string segments without allocation.