Merge branch 'main' into leetcode-3163

Author: ajay-dhangar

blog/Introduction to Cryptography and Cyber security.md renamed to blog/introduction-to-cryptography-and-cyber-security.md

@@ -1,5 +1,5 @@
 ---
-title: 'Cryptography and Its Use in Cyber Security'
+title: "Cryptography and Its Use in Cyber Security"
 sidebar_label: Cryptography and Cyber Security
 authors: [pujan-sarkar]
 tags: [cryptography, cyber security, encryption, technology]
@@ -81,4 +81,3 @@ Zero-knowledge proofs enable one party to prove to another that a statement is t
 ## Conclusion
 
 Cryptography is a cornerstone of cyber security, providing the means to protect data and maintain privacy in an increasingly interconnected world. As technology advances and new threats emerge, the field of cryptography will continue to evolve, offering innovative solutions to ensure the security and integrity of our digital lives. By understanding and implementing cryptographic techniques, individuals and organizations can safeguard their information and build a secure future.
-

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

@@ -4,36 +4,36 @@ title: "Dynamic Content with JavaScript"
 sidebar_label: Dynamic Content
 sidebar_position: 3
 description: "Learn to Dynamic Content with JavaScript."
-tags: [courses,advance-level,Dynamic Content,Introduction]
----  
-  
- 
+tags: [courses, advance-level, Dynamic Content, Introduction]
+---
 
 JavaScript allows for dynamic manipulation of HTML content, enabling developers to create interactive web applications. This can involve modifying the DOM, responding to user events, and dynamically generating content.
 
 **1. Changing Text Content:**
+
 ```html
 <button id="changeText">Change Text</button>
 <p id="dynamicText">Original Text</p>
 
 <script>
-    document.getElementById('changeText').onclick = function() {
-        document.getElementById('dynamicText').textContent = 'Text Changed!';
-    };
+  document.getElementById("changeText").onclick = function () {
+    document.getElementById("dynamicText").textContent = "Text Changed!";
+  };
 </script>
 ```
 
 **2. Creating Elements Dynamically:**
+
 ```html
 <button id="addElement">Add Element</button>
 <div id="container"></div>
 
 <script>
-    document.getElementById('addElement').onclick = function() {
-        const newElement = document.createElement('p');
-        newElement.textContent = 'New Element Added!';
-        document.getElementById('container').appendChild(newElement);
-    };
+  document.getElementById("addElement").onclick = function () {
+    const newElement = document.createElement("p");
+    newElement.textContent = "New Element Added!";
+    document.getElementById("container").appendChild(newElement);
+  };
 </script>
 ```
 
@@ -45,25 +45,25 @@ Using the Fetch API to retrieve data dynamically from an external source.
 <div id="dataContainer"></div>
 
 <script>
-    document.getElementById('fetchData').onclick = function() {
-        fetch('https://jsonplaceholder.typicode.com/posts/1')
-            .then(response => response.json())
-            .then(data => {
-                document.getElementById('dataContainer').innerHTML = `
+  document.getElementById("fetchData").onclick = function () {
+    fetch("https://jsonplaceholder.typicode.com/posts/1")
+      .then((response) => response.json())
+      .then((data) => {
+        document.getElementById("dataContainer").innerHTML = `
                     <h2>${data.title}</h2>
                     <p>${data.body}</p>
                 `;
-            });
-    };
+      });
+  };
 </script>
 ```
 
 ### Summary Table
 
-| Feature                        | Description                                     |
-|--------------------------------|-------------------------------------------------|
-| **Embedding JavaScript**       | Inline, internal, or external scripts in HTML. |
-| **Using Frameworks**           | Integrate HTML with JavaScript frameworks like React. |
-| **Dynamic Content**            | Modify the DOM, create elements, and fetch data dynamically with JavaScript. |
+| Feature                  | Description                                                                  |
+| ------------------------ | ---------------------------------------------------------------------------- |
+| **Embedding JavaScript** | Inline, internal, or external scripts in HTML.                               |
+| **Using Frameworks**     | Integrate HTML with JavaScript frameworks like React.                        |
+| **Dynamic Content**      | Modify the DOM, create elements, and fetch data dynamically with JavaScript. |
 
-By effectively integrating HTML and JavaScript, developers can create engaging, interactive web applications that enhance user experience and functionality.
+By effectively integrating HTML and JavaScript, developers can create engaging, interactive web applications that enhance user experience and functionality.

courses/HTML/advanced-level/Integration-With-JS/Dyanamic-Concept.md

@@ -1,49 +1,50 @@
 ---
-id: lesson-3
+id: lesson-2
 title: "Using HTML with JavaScript Frameworks (e.g., React.js)"
 sidebar_label: HTML with Frameworks
-sidebar_position: 3
+sidebar_position: 2
 description: "Learn to Using HTML with JavaScript Frameworks (e.g., React.js)."
-tags: [courses,advance-level,Frameworks,Introduction]
----  
-  
-  
+tags: [courses, advance-level, Frameworks, Introduction]
+---
 
 JavaScript frameworks like React.js enable developers to build complex user interfaces using HTML-like syntax (JSX). React components encapsulate HTML and JavaScript, promoting a component-based architecture.
 
 **Basic React Component:**
+
 ```javascript
-import React from 'react';
+import React from "react";
 
 function Greeting() {
-    return <h1>Hello, World!</h1>;
+  return <h1>Hello, World!</h1>;
 }
 
 export default Greeting;
 ```
 
 **Rendering a React Component:**
+
 ```javascript
-import React from 'react';
-import ReactDOM from 'react-dom';
-import Greeting from './Greeting';
+import React from "react";
+import ReactDOM from "react-dom";
+import Greeting from "./Greeting";
 
-ReactDOM.render(<Greeting />, document.getElementById('root'));
+ReactDOM.render(<Greeting />, document.getElementById("root"));
 ```
 
 **HTML File:**
+
 ```html
-<!DOCTYPE html>
+<!doctype html>
 <html lang="en">
-<head>
-    <meta charset="UTF-8">
+  <head>
+    <meta charset="UTF-8" />
     <title>React Example</title>
     <script src="https://unpkg.com/react/umd/react.development.js"></script>
     <script src="https://unpkg.com/react-dom/umd/react-dom.development.js"></script>
     <script src="path/to/your/bundle.js" type="text/babel"></script>
-</head>
-<body>
+  </head>
+  <body>
     <div id="root"></div>
-</body>
+  </body>
 </html>
-```
+```

courses/HTML/advanced-level/Integration-With-JS/Frameworks.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.