Merge branch 'main' into other

Author: Ishitamukherjee2004

blog/Introduction to the Linux development and Cyber security renamed to blog/introduction-to-the-Linux-development-and-cyber-security.md

@@ -1,8 +1,8 @@
 ---
-id: lesson-1
+id: lesson-3
 title: "Data Validation in MongoDB"
 sidebar_label: Data Validation
-sidebar_position: 1
+sidebar_position: 3
 description: "Data Validation in MongoDB"
 tags: [courses,beginner-level,Data Validation,Introduction]
 ---  

courses/MongoDB/intermediate-Level/Data-Validation/Schema-validation.md

@@ -204,8 +204,8 @@ const config = {
           },
 
           {
-            to: "/blog",
-            html: '<span class="nav-emoji">📰</span> Blog',
+            to: "/blogs",
+            html: '<span class="nav-emoji">📰</span> Blogs',
           },
 
           {

docusaurus.config.js

@@ -0,0 +1,122 @@
+---
+id: largest-element-in-array
+title: Largest Element In Array
+sidebar_label: Largest-Element-In-Array
+tags:
+  - Arrays
+  - Data Structure
+description: "This tutorial covers the solution to the Largest Element In Array problem from the GeeksforGeeks website, featuring implementations in C++."
+---
+## Problem Description
+Given an array `arr`, the task is to find the largest element in it.
+
+## Examples
+
+**Example 1:**
+
+```
+Input: arr= [1, 8, 7, 56, 90]
+Output: 90
+Explanation: The largest element of given array is 90.
+```
+
+**Example 2:**
+
+```
+Input: arr = [5, 5, 5, 5]
+Output: 5
+Explanation: The largest element of given array is 5.
+```
+
+## Your Task
+
+You don't need to read input anything. Your task is to complete the function `largest()` which takes the array `arr` and an size of array as `n` as input parameters and returns the largest number.
+
+Expected Time Complexity: O(n)
+
+Expected Auxiliary Space: O(1)
+
+## Constraints
+
+* `1 <= arr.size()<= 10^5`
+
+## Problem Explanation
+
+The task is to traverse the whole array and find the largest element of that array.
+
+## Code Implementation
+
+### C++ Solution
+
+
+```cpp
+class Solution
+{
+public:
+    int largest(vector<int> &arr, int n)
+    {
+        int maxi = INT_MIN;
+        for(int i=0; i<n; i++){
+            maxi = max(arr[i], maxi);
+        }
+        return maxi;
+    }
+};
+```
+
+```java
+public class Solution {
+    public int largest(int[] arr) {
+        int maxi = Integer.MIN_VALUE;
+        for (int i = 0; i < arr.length; i++) {
+            maxi = Math.max(arr[i], maxi);
+        }
+        return maxi;
+    }
+}
+
+```
+
+```python
+class Solution:
+    def largest(self, arr):
+        maxi = float('-inf')
+        for i in range(len(arr)):
+            maxi = max(arr[i], maxi)
+        return maxi
+
+```
+
+```javascript
+class Solution {
+    largest(arr) {
+        let maxi = -Infinity;
+        for (let i = 0; i < arr.length; i++) {
+            maxi = Math.max(arr[i], maxi);
+        }
+        return maxi;
+    }
+}
+
+```
+
+```typescript
+class Solution {
+    largest(arr: number[]) {
+        let maxi = -Infinity;
+        for (let i = 0; i < arr.length; i++) {
+            maxi = Math.max(arr[i], maxi);
+        }
+        return maxi;
+    }
+}
+
+``
+
+## Time Complexity
+
+* The time complexity is $$O(n)$$ where n is the length of the input array. This is because we are iterating through the array once to find the maximum element. 
+
+## Space Complexity
+
+* The auxiliary space complexity is $O(1)$ which means the space required does not change with the size of the input array. This is because we are only using a fixed amount of space to store the maximum element and the index.

dsa-solutions/gfg-solutions/Easy problems/Largest-Element-In-Array.md

@@ -0,0 +1,152 @@
+---
+id: sorted-arrray-search
+title: Sorted Array Search
+sidebar_label: Sorted-Array-Search
+tags:
+  - Searching
+  - Binary Search
+  - Algorithms
+description: "This tutorial covers the solution to the Sorted Array Search problem from the GeeksforGeeks website."
+---
+## Problem Description
+Given an array `arr[]` sorted in ascending order of size `N` and an integer `K`. Check if `K` is present in the array or not.
+
+## Examples
+
+**Example 1:**
+
+```
+Input:
+N = 5, K = 6
+arr[] = {1,2,3,4,6}
+Output: 1
+Exlpanation: Since, 6 is present in 
+the array at index 4 (0-based indexing),
+output is 1.
+```
+
+**Example 2:**
+
+```
+Input:
+N = 5, K = 2
+arr[] = {1,3,4,5,6}
+Output: -1
+Exlpanation: Since, 2 is not present 
+in the array, output is -1.
+```
+
+## Your Task
+
+You don't need to read input or print anything. Complete the function searchInSorted() which takes the sorted array arr[], its size N and the element K as input parameters and returns 1 if K is present in the array, else it returns -1. 
+
+
+
+Expected Time Complexity: O(Log N)
+
+Expected Auxiliary Space: O(1)
+
+## Constraints
+
+* `1 <= arr[i] <= 10^6`
+
+## Problem Explanation
+
+The task is to traverse the array and find the reuired element.
+
+## Code Implementation
+
+### C++ Solution
+
+```cpp
+class Solution{
+    public:
+    // Function to find element in sorted array
+    // arr: input array
+    // N: size of array
+    // K: element to be searche
+    int searchInSorted(int arr[], int N, int K) 
+    { 
+       int cnt = 0;
+       for(int i=0; i<N; i++){
+           if(arr[i]==K) {
+           cnt = 1;
+           break;
+               
+           }
+       }
+       if(cnt==1) return 1;
+       return -1;
+       
+    }
+};
+```
+
+```java
+public class Solution {
+    public int searchInSorted(int[] arr, int N, int K) {
+        for (int i = 0; i < N; i++) {
+            if (arr[i] == K) {
+                return 1;
+            }
+        }
+        return -1;
+    }
+}
+
+```
+
+```python
+
+class Solution:
+    def searchInSorted(self, arr, N, K):
+        for i in range(N):
+            if arr[i] == K:
+                return 1
+        return -1
+
+```
+
+```javascript
+class Solution {
+    searchInSorted(arr, N, K) {
+        for (let i = 0; i < N; i++) {
+            if (arr[i] === K) {
+                return 1;
+            }
+        }
+        return -1;
+    }
+}
+
+```
+
+```typescript
+class Solution {
+    searchInSorted(arr: number[], N: number, K: number): number {
+        for (let i = 0; i < N; i++) {
+            if (arr[i] === K) {
+                return 1;
+            }
+        }
+        return -1;
+    }
+}
+```
+
+## Solution Logic:
+
+1. Iterate through the sorted array from the beginning to the end.
+2. Check if the current element is equal to the target element (K).
+3. If it is, return 1 to indicate that the element is found.
+4. If the loop completes without finding the element, return -1 to indicate that the element is not found.
+
+
+## Time Complexity
+
+* The time complexity is $O(N)$, the algorithm iterates through the array once, where N is the size of the array.Each iteration performs a constant amount of work, so the time complexity is linear.
+
+
+## Space Complexity
+
+* The auxiliary space complexity is $O(1)$ due to the algorithm only uses a fixed amount of space to store the indices and the target element.