Merge branch 'main' into 888

Author: ajay-dhangar

docs/SQL/SQL-Where-Clause.md

@@ -0,0 +1,86 @@
+---
+id: sql-where-clause
+title: Where Clause in SQL
+sidebar_label: Where Clause
+sidebar_position: 3
+tags: [sql, database, clause]
+description: In this tutorial, you will learn how to build queries with conditions to get the desired output.
+---
+
+The WHERE clause in SQL is used to filter records from a result set. It specifies the conditions that must be met for the rows to be included in the result. The WHERE clause is often used in SELECT, UPDATE, DELETE, and other SQL statements to narrow down the data returned or affected.
+
+## Syntax 
+```sql
+SELECT column1, column2, ...
+FROM table_name
+WHERE condition;
+```
+
+## Operators Used in the WHERE Clause
+1. `=` : Equal
+2. `>` : Greater than
+3. `<` : Less than
+4. `>=` : Greater than or equal
+5. `<=` : Less than or equal
+6. `<>` : Not equal (Note: In some versions of SQL, this operator may be written as `!=`)
+7. `BETWEEN` : Between a certain range
+8. `LIKE` : Search for a pattern
+9. `IN` : To specify multiple possible values for a column
+
+## Advantages of SQL WHERE Clause
+
+1. **Filtering Rows:** The WHERE clause evaluates each row in the table to determine if it meets the specified condition(s). Only rows that satisfy the condition are included in the result set.
+2. **Conditions:** Conditions in the WHERE clause can use comparison operators like `=`, `<>` (not equal), `>`, `<`, `>=`, `<=`. Logical operators such as `AND`, `OR`, and `NOT` can be used to combine multiple conditions.
+3. **Pattern Matching:** The LIKE operator can be used for pattern matching. For example, `LIKE 'A%'` matches any string that starts with the letter 'A'.
+4. **Range Checks:** The BETWEEN operator checks if a value is within a range of values. For example, `BETWEEN 10 AND 20`.
+5. **Null Values:** The `IS NULL` and `IS NOT NULL` operators are used to filter records with null values.
+
+## Examples of WHERE Clause in SQL
+
+### Basic Select Query
+```sql
+SELECT * FROM Students WHERE marks > 50;
+```
+
+### WHERE Clause in UPDATE Statement
+```sql
+UPDATE employees SET salary = salary * 1.10
+WHERE performance_rating = 'Excellent';
+```
+
+### WHERE Clause in DELETE Statement
+```sql
+DELETE FROM employees
+WHERE last_login < '2023-01-01';
+```
+
+### WHERE Clause with LIKE Statement
+```sql
+SELECT * FROM customers
+WHERE name LIKE 'J%';
+```
+
+### WHERE Clause with BETWEEN Statement
+```sql
+SELECT * FROM orders
+WHERE order_date BETWEEN '2023-01-01' AND '2023-12-31';
+```
+
+### WHERE Clause with IS NULL Statement
+```sql
+SELECT * FROM employees
+WHERE manager_id IS NULL;
+```
+
+## Conclusion
+The WHERE clause in SQL is a powerful tool for filtering data in various SQL statements. It allows you to specify conditions that rows must meet to be included in the result set, thereby enabling precise data retrieval and manipulation. By using comparison operators, logical operators, pattern matching, range checks, and handling null values, you can create complex queries tailored to your specific data requirements. Mastering the WHERE clause is essential for efficient database management and analysis, providing the ability to focus on relevant data and perform targeted updates and deletions.
+
+---
+
+## Authors:
+
+<div style={{display: 'flex', flexWrap: 'wrap', justifyContent: 'space-between', gap: '10px'}}>
+  {['damini-chachane'].map(username => (
+    <Author key={username} username={username} />
+  ))}
+</div>

docs/SQL/image.png

@@ -338,7 +338,7 @@ export const problems = [
     "problemName": "454. 4Sum II",
     "difficulty": "Medium",
     "leetCodeLink": "https://leetcode.com/problems/4sum-ii",
-    "solutionLink": "#"
+    "solutionLink": "/dsa-solutions/lc-solutions/0400-0499/4Sum-II"
   },
   {
     "problemName": "455. Assign Cookies",
@@ -619,4 +619,4 @@ export const problems = [
     collectionLink="https://leetcode.com/study-plan/programming-skills"
 />
 
-Now, you can see the list of problems in a table format. You can click on the problem link to view the problem on the LeetCode website. You can also click on the solution link to view the solution of the problem.
+Now, you can see the list of problems in a table format. You can click on the problem link to view the problem on the LeetCode website. You can also click on the solution link to view the solution of the problem.

docs/dsa/algorithms/image-7.png

@@ -0,0 +1,192 @@
+---
+id: binary-search
+title: Binary Search
+sidebar_label: 0001 Binary Search
+tags:
+- Array
+- C
+- Python
+- Java
+- C++
+description: "This document provides solutions to the problem of performing Binary Search in a sorted array."
+---
+
+## Problem
+
+Given a sorted array of size N and an integer K, find the position(0-based indexing) at which K is present in the array using binary search.
+
+### Examples
+**Example 1:**
+```
+Input:
+N = 5
+arr[] = {1 2 3 4 5} 
+K = 4
+Output: 3
+Explanation: 4 appears at index 3.
+```
+ 
+**Example 2:**
+```
+Input:
+N = 5
+arr[] = {11 22 33 44 55} 
+K = 445
+Output: -1
+Explanation: 445 is not present.
+```
+
+### Your Task:
+You dont need to read input or print anything. Complete the function **binarysearch()** which takes **arr[]**, **N** and **K** as input parameters and returns the index of **K** in the array. If **K** is not present in the array, return -1.
+
+- **Expected Time Complexity:** $O(LogN)$
+- **Expected Auxiliary Space:** $O(LogN)$ if solving recursively and $O(1)$ otherwise.
+
+### Constraints:
+
+- $1 <= N <= 10^5$
+- $1 <= arr[i] <= 10^6$
+- $1 <= K <= 10^6$
+
+## Solution:
+### Iterative Approach:
+
+**Python**
+```python
+def binarysearch(self, arr, n, k):
+    low = 0
+    high = n-1
+    while low<=high:
+        mid = low + (high-low)//2
+        if arr[mid]==k:
+            return mid
+        elif arr[mid]<k:
+            low = mid+1
+        else:
+            high = mid-1
+    return -1
+```
+
+**Java**
+```java
+int binarysearch(int arr[], int n, int k) {
+    int high = n-1;
+    int low = 0;
+    while (low<=high) {
+        int mid = low+(high-low)/2;
+        if (arr[mid]==k)
+            return mid;
+        else if (arr[mid]<k)
+            low = mid+1;
+        else
+            high = mid-1;
+    }
+    return -1;
+}
+```
+
+**C++**
+```cpp
+int binarysearch(int arr[], int n, int k) {
+    int high = n - 1;
+    int low = 0;
+    while (low <= high) {
+        int mid = low + (high - low) / 2;
+        if (arr[mid] == k)
+            return mid;
+        else if (arr[mid] < k)
+            low = mid + 1;
+        else
+            high = mid - 1;
+    }
+    return -1;
+}
+```
+
+**C**
+```c
+int binarysearch(int arr[], int n, int k) {
+    int high = n - 1;
+    int low = 0;
+    while (low <= high) {
+        int mid = low + (high - low) / 2;
+        if (arr[mid] == k)
+            return mid;
+        else if (arr[mid] < k)
+            low = mid + 1;
+        else
+            high = mid - 1;
+    }
+    return -1;
+}
+```
+
+- **Time Complexity:** $O(log n)$
+- **Space Complexity:** $O(1)$
+
+### Recursive Approach
+**Python**
+```python
+def binarysearch(arr, low, high, k):
+    if low <= high:
+        mid = low + (high - low) // 2
+        if arr[mid] == k:
+            return mid
+        elif arr[mid] < k:
+            return binarysearch(arr, mid + 1, high, k)
+        else:
+            return binarysearch(arr, low, mid - 1, k)
+    else:
+        return -1
+```
+
+**Java**
+```java
+int binarysearch(int arr[], int low, int high, int k) {
+    if (low <= high) {
+        int mid = low + (high - low) / 2;
+        if (arr[mid] == k)
+            return mid;
+        else if (arr[mid] < k)
+            return binarysearch(arr, mid + 1, high, k);
+        else
+            return binarysearch(arr, low, mid - 1, k);
+    }
+    return -1;
+}
+```
+
+**C++**
+```cpp
+int binarysearch(int arr[], int low, int high, int k) {
+    if (low <= high) {
+        int mid = low + (high - low) / 2;
+        if (arr[mid] == k)
+            return mid;
+        else if (arr[mid] < k)
+            return binarysearch(arr, mid + 1, high, k);
+        else
+            return binarysearch(arr, low, mid - 1, k);
+    }
+    return -1;
+}
+```
+
+**C**
+```c
+int binarysearch(int arr[], int low, int high, int k) {
+    if (low <= high) {
+        int mid = low + (high - low) / 2;
+        if (arr[mid] == k)
+            return mid;
+        else if (arr[mid] < k)
+            return binarysearch(arr, mid + 1, high, k);
+        else
+            return binarysearch(arr, low, mid - 1, k);
+    }
+    return -1;
+}
+```
+
+- **Time Complexity:** $O(log n)$
+- **Space Complexity:** $O(log n)$

dsa-problems/leetcode-problems/0400-0499.md

@@ -0,0 +1,101 @@
+---
+id: peak-element
+title: Peak Element
+sidebar_label: 0002 Peak Element
+tags:
+- Array
+- C
+- Python
+- Java
+- C++
+description: "This document provides solutions to the problem of finding peak element in an array."
+---
+
+## Problem
+
+Given an 0-indexed array of integers *arr[]* of size *n*, find its peak element and return it's index. An element is considered to be peak if it's value is greater than or equal to the values of its adjacent elements (if they exist).
+
+Note: The output will be 1 if the index returned by your function is correct; otherwise, it will be 0.
+
+### Examples:
+**Example 1:**
+```
+Input: n = 3, arr[] = {1, 2, 3} 
+Output: 1
+Explanation: If the index returned is 2, then the output printed will be 1. Since arr[2] = 3 is greater than its adjacent elements, and there is no element after it, we can consider it as a peak element. No other index satisfies the same property, so answer will be printed as 0.
+```
+
+**Example 2:**
+```
+Input: n = 7, arr[] = {1, 1, 1, 2, 1, 1, 1}
+Output: 1
+Explanation: In this case there are 5 peak elements with indices as {0,1,3,5,6}. Returning any of them will give you correct answer.
+```
+
+## Solution 
+**Python**
+```python
+def peakElement(self,arr, n):
+    if (n == 1) :
+        return 0
+    if (arr[0] >= arr[1]) :
+        return 0
+    if (arr[n - 1] >= arr[n - 2]) :
+        return n - 1
+    for i in range(1, n - 1) :
+        if (arr[i] >= arr[i - 1] and arr[i] >= arr[i + 1]) :
+            return i
+```
+
+**Java**
+```java
+public int peakElement(int[] arr,int n) {
+    if (n == 1)
+        return 0;
+    if (arr[0] >= arr[1])
+        return 0;
+    if (arr[n - 1] >= arr[n - 2])
+        return n - 1;
+    for (int i = 1; i < n - 1; i++) {
+        if (arr[i] >= arr[i - 1] && arr[i] >= arr[i + 1])
+            return i;
+    }
+    return 0;
+}
+```
+
+**C++**
+```cpp
+public:
+int peakElement(int arr[], int n) {
+    if (n == 1)
+    return 0;
+    if (arr[0] >= arr[1])
+        return 0;
+    if (arr[n - 1] >= arr[n - 2])
+        return n - 1;
+    for (int i = 1; i < n - 1; i++) {
+        if (arr[i] >= arr[i - 1] && arr[i] >= arr[i + 1])
+            return i;
+    }
+}
+```
+
+**C**
+```c
+int peakElement(int arr[], int n) {
+   if (n == 1)
+    return 0;
+    if (arr[0] >= arr[1])
+        return 0;
+    if (arr[n - 1] >= arr[n - 2])
+        return n - 1;
+    for (int i = 1; i < n - 1; i++) {
+        if (arr[i] >= arr[i - 1] && arr[i] >= arr[i + 1])
+            return i;
+    }
+}
+```
+
+- **Time complexity:** $O(n)$
+- **Space complexity:**: $O(1)$