Merge branch 'CodeHarborHub:main' into PradnyaGaitonde-patch-30

Author: PradnyaGaitonde

docs/SQL/SQL-NOT-Operator.md

@@ -0,0 +1,88 @@
+---
+id: sql-not-operator
+title: Not Operator in SQL
+sidebar_label: Not Operator
+sidebar_position: 5
+tags: [sql, database, operator]
+description: In this tutorial, you will learn how to build queries with Negations to get the desired output.
+---
+
+
+In SQL, the NOT operator is used to negate a condition in a WHERE clause or other SQL statement. Its primary function is to reverse the logical meaning of the condition that follows it. 
+
+## Syntax 
+```sql
+SELECT column1, column2, ...
+FROM table_name
+WHERE NOT condition;
+
+```
+
+## Advantages of SQL NOT Operator
+
+**1.Exclusion of Unwanted Records:**
+- The NOT operator allows you to exclude records that match a certain condition. This is useful when you need to filter out specific data from your results.
+
+**2.Simplification of Complex Conditions:**
+- It simplifies the writing of complex conditions by directly specifying what should not be included. Without the NOT operator, you might have to write more convoluted logic.
+
+**3.Enhanced Readability and Maintainability:**
+- Using NOT can make the intention of the query clearer to someone reading the SQL code. Clearer code is easier to maintain and less prone to errors.
+
+**4.Combination with Other Operators:**
+- The NOT operator can be combined with other operators such as IN, BETWEEN, and LIKE to provide more nuanced data filtering.
+
+**5.Handling NULL Values:**
+- The NOT operator can also be used effectively with IS NULL or IS NOT NULL to filter out or include rows with NULL values.
+
+**6.Flexibility in Subqueries:**
+- When used with subqueries, the NOT operator can help exclude sets of records efficiently.
+
+**7.Versatility in Logical Expressions:**
+- It can be used to invert the result of any logical expression, providing versatility in query construction.
+
+## Examples of Not Operator in SQL
+
+### NOT LIKE
+```sql
+SELECT * FROM Customers
+WHERE CustomerName NOT LIKE 'A%';
+```
+
+### NOT BETWEEN
+```sql
+SELECT * FROM Customers
+WHERE CustomerID NOT BETWEEN 10 AND 60;
+```
+
+### NOT IN
+```sql
+SELECT * FROM Customers
+WHERE City NOT IN ('Paris', 'London');
+```
+
+### NOT Greater Than
+```sql
+SELECT * FROM Customers
+WHERE NOT CustomerID > 50;
+```
+
+### NOT Less Than
+```sql
+SELECT * FROM Customers
+WHERE NOT CustomerId < 50;
+```
+
+
+## Conclusion
+The NOT operator in SQL provides a straightforward way to negate conditions in SQL queries, allowing for more flexible and precise data retrieval. Understanding its usage is crucial for crafting effective SQL statements, particularly when dealing with complex filtering requirements.
+
+---
+
+## Authors:
+
+<div style={{display: 'flex', flexWrap: 'wrap', justifyContent: 'space-between', gap: '10px'}}>
+  {['damini-chachane'].map(username => (
+    <Author key={username} username={username} />
+  ))}
+</div>

docusaurus.config.js

@@ -343,6 +343,12 @@ const config = {
                 label: "Cookie Policy",
                 to: "/cookie-policy",
               },
+
+              {
+                label: "Licensing",
+                to: "/License/",
+              },
+
             ],
           },
           {

dsa-problems/leetcode-problems/0900-0999.md

@@ -117,13 +117,13 @@ export const problems = [
         problemName: "917. Reverse Only Letters",
         difficulty: "Easy",
         leetCodeLink: "https://leetcode.com/problems/reverse-only-letters",
-        solutionLink: "#"
+        solutionLink: "/dsa-solutions/lc-solutions/0900-0999/reverse-only-letters"
     },
     {
         problemName: "918. Maximum Sum Circular Subarray",
         difficulty: "Medium",
         leetCodeLink: "https://leetcode.com/problems/maximum-sum-circular-subarray",
-        solutionLink: "#"
+        solutionLink: "/dsa-solutions/lc-solutions/0900-0999/maximum-sum-circular-subarray"
     },
     {
         problemName: "919. Complete Binary Tree Inserter",

dsa-problems/leetcode-problems/3100-3199.md

@@ -448,6 +448,12 @@ export const problems = [
 "leetCodeLink": "https://leetcode.com/problems/maximum-total-reward-using-operations-ii",
 "solutionLink": "#"
 },
+{
+"problemName": "3183. The Number of Ways To Make The Sum",
+"difficulty": "Medium",
+"leetCodeLink": "https://leetcode.com/problems/the-number-of-ways-to-make-the-sum",
+"solutionLink": "#"
+},
 ];
 
 <Table 

dsa-solutions/lc-solutions/0000-0099/0079-word-search.md

@@ -0,0 +1,118 @@
+---
+id: word-search
+title: Word Search(LeetCode)
+sidebar_label: 0079-Word Search
+tags:
+  - Array
+  - String
+  - Backtracking
+  - Matrix
+description: Given an m x n grid of characters board and a string word, return true if word exists in the grid.
+---
+
+## Problem Statement
+
+Given an `m x n` grid of characters `board` and a string `word`, return `true` if `word` exists in the grid.
+
+The word can be constructed from letters of sequentially adjacent cells, where adjacent cells are horizontally or vertically neighboring. The same letter cell may not be used more than once.
+
+### Examples
+
+**Example 1:**
+
+![image](https://github.com/PradnyaGaitonde/codeharborhub.github.io/assets/116059908/dc23f6be-e216-4ad1-89bc-178cf3039262)
+
+```plaintext
+Input: board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], word = "ABCCED"
+Output: true
+```
+
+**Example 2:**
+
+![image](https://github.com/PradnyaGaitonde/codeharborhub.github.io/assets/116059908/c3905a94-2a40-4dee-a4bf-42b77ba2b91a)
+
+```plaintext
+Input: board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], word = "SEE"
+Output: true
+```
+
+**Example 3:**
+
+![image](https://github.com/PradnyaGaitonde/codeharborhub.github.io/assets/116059908/c56f9ea3-8247-484b-943a-0c38ea32465c)
+
+```plaintext
+Input: board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], word = "ABCB"
+Output: false
+```
+
+### Constraints
+
+- `m == board.length`
+- `n = board[i].length`
+- `1 <= m, n <= 6`
+- `1 <= word.length <= 15`
+- `board` and `word` consists of only lowercase and uppercase English letters.
+
+## Solution
+
+### Approach 
+
+#### Algorithm
+
+1. Initialization:
+* Convert the input word to a character array `w`.
+* Iterate through each cell in the board using nested loops.
+2. Recursive Search:
+* For each cell in the board, call the recursive function `exist`.
+* The recursive function `exist` takes parameters: the board, current cell coordinates `(y, x)`, the word array, and the current index `i` in the word array.
+* Base cases:
+  * If `i` equals the length of the word, return `true` (all characters are matched).
+  * If the current cell `(y, x)` is out of bounds or does not match the current character in the word array, return `false`.
+* Mark the current cell as visited by toggling the 8th bit using `board[y][x] ^= 256`.
+* Recursively check all four possible directions (right, left, down, up) from the current cell.
+* After the recursive calls, unmark the current cell by toggling the 8th bit again using `board[y][x] ^= 256`.
+* Return `true` if any of the recursive calls return `true`, indicating that the word exists in the board starting from the current cell.
+3. Return Result:
+* Return `true` if the word is found starting from any cell, otherwise return `false`.
+
+#### Implementation
+
+```Java
+public boolean exist(char[][] board, String word) {
+    char[] w = word.toCharArray();
+    for (int y=0; y<board.length; y++) {
+    	for (int x=0; x<board[y].length; x++) {
+    		if (exist(board, y, x, w, 0)) return true;
+    	}
+    }
+    return false;
+}
+
+private boolean exist(char[][] board, int y, int x, char[] word, int i) {
+	if (i == word.length) return true;
+	if (y<0 || x<0 || y == board.length || x == board[y].length) return false;
+	if (board[y][x] != word[i]) return false;
+	board[y][x] ^= 256;
+	boolean exist = exist(board, y, x+1, word, i+1)
+		|| exist(board, y, x-1, word, i+1)
+		|| exist(board, y+1, x, word, i+1)
+		|| exist(board, y-1, x, word, i+1);
+	board[y][x] ^= 256;
+	return exist;
+}
+```
+
+### Complexity Analysis
+
+- **Time complexity**: $O(N.3^L)$ 
+  * N is the number of cells in the board (i.e., board.length * board[0].length).
+  * L is the length of the word.
+  * Each cell can be a starting point, and from each cell, we explore up to 3 directions (since we cannot revisit the previous cell, reducing from 4 to 3).
+
+- **Space complexity**: O(L)
+  * The recursion stack can go up to a depth of L, which is the length of the word.
+  * No additional data structures are used that grow with input size (in-place modification of the board is used).
+
+### Conclusion
+
+This recursive solution effectively finds the word in the board by exploring all possible paths and backtracking when a path does not lead to the solution. By marking cells with a bitmask, it avoids using additional memory for visited states, making the algorithm space-efficient. The time complexity reflects the worst-case scenario of exploring all possible paths, while the space complexity is primarily driven by the depth of the recursion stack. This approach is both time and space-efficient, making it suitable for large boards and words.