created README.md

Signed-off-by: rajput-hemant <[email protected]>

Author: rajput-hemant

Diff for: src/0001-0100/004 - Median of Two Sorted Arrays/README.md

@@ -0,0 +1,75 @@
+# 4. Median of Two Sorted Arrays [![share]](https://leetcode.com/problems/median-of-two-sorted-arrays)
+
+![][hard]
+
+## Problem Statement:
+
+Given two sorted arrays `nums1` and `nums2` of size `m` and `n` respectively, return **the median** of the two sorted arrays.
+
+The overall run time complexity should be `O(log (m+n))`.
+
+### Example 1:
+
+```
+Input: nums1 = [1,3], nums2 = [2]
+Output: 2.00000
+Explanation: merged array = [1,2,3] and median is 2.
+```
+
+### Example 2:
+
+```
+Input: nums1 = [1,2], nums2 = [3,4]
+Output: 2.50000
+Explanation: merged array = [1,2,3,4] and median is (2 + 3) / 2 = 2.5.
+```
+
+### Constraints:
+
+- nums1.length == m
+- nums2.length == n
+- 0 <= m <= 1000
+- 0 <= n <= 1000
+- 1 <= m + n <= 2000
+- -10<sup>6</sup> <= nums1[i], nums2[i] <= 10<sup>6</sup>
+
+## Solutions
+
+### [_Java_](./MedianOfTwoSortedArrays.java)
+
+```java
+public class MedianOfTwoSortedArrays {
+  public static double findMedianSortedArrays(int[] nums1, int[] nums2) {
+      int[] merged = new int[nums1.length + nums2.length];
+      int startnums1 = 0, startnums2 = 0, i = 0;
+      while (startnums1 < nums1.length && startnums2 < nums2.length) {
+          if (nums1[startnums1] < nums2[startnums2])
+              merged[i++] = nums1[startnums1++];
+          else
+              merged[i++] = nums2[startnums2++];
+      }
+      while (startnums1 < nums1.length)
+          merged[i++] = nums1[startnums1++];
+      while (startnums2 < nums2.length)
+          merged[i++] = nums2[startnums2++];
+      double median = 0;
+      int mid = merged.length / 2;
+      if (merged.length % 2 == 0)
+          median = (double) (merged[mid] + merged[mid - 1]) / 2;
+      else
+          median = (double) merged[mid];
+      return median;
+  }
+}
+```
+
+### [_..._]()
+
+```
+
+```
+
+<!----------------------------------{ link }--------------------------------->
+
+[share]: https://img.icons8.com/external-anggara-blue-anggara-putra/20/000000/external-share-user-interface-basic-anggara-blue-anggara-putra-2.png
+[hard]: https://img.shields.io/badge/Difficulty-Hard-red.svg

Diff for: src/0001-0100/024 - Swap Nodes in Pairs/README.md

@@ -0,0 +1,66 @@
+# 24. Swap Nodes in Pairs [![share]](https://leetcode.com/problems/swap-nodes-in-pairs)
+
+![][medium]
+
+## Problem Statement:
+
+Given a linked list, swap every two adjacent nodes and return its head. You must solve the problem without modifying the values in the list's nodes (i.e., only nodes themselves may be changed.)
+
+![](https://assets.leetcode.com/uploads/2020/10/03/swap_ex1.jpg)
+
+### Example 1:
+
+```
+Input: head = [1,2,3,4]
+Output: [2,1,4,3]
+```
+
+### Example 2:
+
+```
+Input: head = []
+Output: []
+```
+
+### Example 3:
+
+```
+Input: head = [1]
+Output: [1]
+```
+
+### Constraints:
+
+- The number of nodes in the list is in the range `[0, 100]`.
+- 0 <= Node.val <= 100
+
+## Solutions:
+
+### [_Java_](./SwapNodesInPairs.java)
+
+```java
+public class SwapNodesInPairs {
+
+    public ListNode swapPairs(ListNode head) {
+        ListNode newNode = head;
+        while (newNode != null && newNode.next != null) {
+            int temp = newNode.val;
+            newNode.val = newNode.next.val;
+            newNode.next.val = temp;
+            newNode = newNode.next.next;
+        }
+        return head;
+    }
+}
+```
+
+### [_..._]()
+
+```
+
+```
+
+<!----------------------------------{ link }--------------------------------->
+
+[share]: https://img.icons8.com/external-anggara-blue-anggara-putra/20/000000/external-share-user-interface-basic-anggara-blue-anggara-putra-2.png
+[medium]: https://img.shields.io/badge/Difficulty-Medium-yellow.svg

Diff for: src/0001-0100/026 - Remove Duplicates from Sorted Array/README.md

@@ -0,0 +1,81 @@
+# 26. Remove Duplicates from Sorted Array [![share]](https://leetcode.com/problems/remove-duplicates-from-sorted-array/)
+
+![][easy]
+
+## Problem Statement:
+
+Given an integer array `nums` sorted in **non-decreasing order**, remove the duplicates in-place such that each unique element appears only once. The **relative order** of the elements should be kept the **same**.
+
+Since it is impossible to change the length of the array in some languages, you must instead have the result be placed in the **first part** of the array `nums`. More formally, if there are `k` elements after removing the duplicates, then the first `k` elements of `nums` should hold the final result. It does not matter what you leave beyond the first `k` elements.
+
+Return `k` after placing the final result in the first `k` slots of `nums`.
+
+Do **not** allocate extra space for another array. You must do this by **modifying the input array** in-place with O(1) extra memory.
+
+### Custom Judge:
+
+```
+The judge will test your solution with the following code:
+
+int[] nums = [...]; // Input array
+int[] expectedNums = [...]; // The expected answer with correct length
+
+int k = removeDuplicates(nums); // Calls your implementation
+
+assert k == expectedNums.length;
+for (int i = 0; i < k; i++) {
+    assert nums[i] == expectedNums[i];
+}
+```
+
+If all assertions pass, then your solution will be **accepted**.
+
+### Example 1:
+
+```
+Input: nums = [1,1,2]
+Output: 2, nums = [1,2,_]
+Explanation: Your function should return k = 2, with the first two elements of nums being 1 and 2 respectively.
+It does not matter what you leave beyond the returned k (hence they are underscores).
+```
+
+### Example 2:
+
+```
+Input: nums = [0,0,1,1,1,2,2,3,3,4]
+Output: 5, nums = [0,1,2,3,4,_,_,_,_,_]
+Explanation: Your function should return k = 5, with the first five elements of nums being 0, 1, 2, 3, and 4 respectively.
+It does not matter what you leave beyond the returned k (hence they are underscores).
+```
+
+### Constraints:
+
+- 1 <= nums.length <= 3 \* 10<sup>4</sup>
+- -100 <= nums[i] <= 100
+- nums is sorted in non-decreasing order.
+
+## Solutions:
+
+### [_Python_](./RemoveDuplicatesFromSortedArray.py)
+
+```python
+def removeDuplicates(nums: list[int]) -> int:
+    k = 0
+    for i, item in enumerate(nums):
+        if i < len(nums) - 1 and item == nums[i + 1]:
+            continue
+        nums[k] = item
+        k += 1
+    return k
+```
+
+### [_..._]()
+
+```
+
+```
+
+<!----------------------------------{ link }--------------------------------->
+
+[share]: https://img.icons8.com/external-anggara-blue-anggara-putra/20/000000/external-share-user-interface-basic-anggara-blue-anggara-putra-2.png
+[easy]: https://img.shields.io/badge/Difficulty-Easy-green.svg

Diff for: src/0001-0100/037 - Sudoku Solver/README.md

@@ -0,0 +1,156 @@
+# 37. Sudoku Solver [![share]](https://leetcode.com/problems/sudoku-solver/)
+
+![][hard]
+
+## Problem Statement:
+
+Write a program to solve a Sudoku puzzle by filling the empty cells.
+
+A sudoku solution must satisfy **all of the following rules:**
+
+- Each of the digits `1-9` must occur exactly once in each row.
+- Each of the digits `1-9` must occur exactly once in each column.
+- Each of the digits `1-9` must occur exactly once in each of the 9 `3x3` sub-boxes of the grid.
+- The '.' character indicates empty cells.
+
+### Example 1:
+
+![](https://upload.wikimedia.org/wikipedia/commons/thumb/f/ff/Sudoku-by-L2G-20050714.svg/250px-Sudoku-by-L2G-20050714.svg.png)
+
+```
+Input: board =
+[["5","3",".",".","7",".",".",".","."],
+["6",".",".","1","9","5",".",".","."],
+[".","9","8",".",".",".",".","6","."],
+["8",".",".",".","6",".",".",".","3"],
+["4",".",".","8",".","3",".",".","1"],
+["7",".",".",".","2",".",".",".","6"],
+[".","6",".",".",".",".","2","8","."],
+[".",".",".","4","1","9",".",".","5"],
+[".",".",".",".","8",".",".","7","9"]]
+
+Output:
+[["5","3","4","6","7","8","9","1","2"],
+["6","7","2","1","9","5","3","4","8"],
+["1","9","8","3","4","2","5","6","7"],
+["8","5","9","7","6","1","4","2","3"],
+["4","2","6","8","5","3","7","9","1"],
+["7","1","3","9","2","4","8","5","6"],
+["9","6","1","5","3","7","2","8","4"],
+["2","8","7","4","1","9","6","3","5"],
+["3","4","5","2","8","6","1","7","9"]]
+```
+
+**Explanation**: The input board is shown above and the only valid solution is shown below:
+
+![](https://upload.wikimedia.org/wikipedia/commons/thumb/3/31/Sudoku-by-L2G-20050714_solution.svg/250px-Sudoku-by-L2G-20050714_solution.svg.png)
+
+### Constraints:
+
+- board.length == 9
+- board[i].length == 9
+- board[i][j] is a digit or '.'.
+- It is **guaranteed** that the input board has only one solution.
+
+## Solutions:
+
+### [_Java_](./SudokuSolver2.java)
+
+```java
+/*
+A sudoku solution must satisfy all of the following rules:
+-> Each of the digits 1-9 must occur exactly once in each row.
+-> Each of the digits 1-9 must occur exactly once in each column.
+-> Each of the digits 1-9 must occur exactly once in each of the 9 3x3 sub-boxes of the grid.
+The "." character indicates empty cells.
+*/
+
+public class SudokuSolver2 {
+    public void solveSudoku(char[][] board) {
+        helper(board, 0, 0);
+    }
+
+    // a utility function to solve the board
+    boolean helper(char[][] board, int row, int col) {
+        // base case -> recursion stops at the 10th row
+        if (row == board.length)
+            return true;
+        int newRow = 0, newCol = 0;
+        // when its the last col of the board, goto next row & first col
+        if (col == board.length - 1) {
+            newRow = row + 1;
+            newCol = 0;
+        }
+        // else, keep increasing the col by one & the row remains the same
+        else {
+            newRow = row;
+            newCol = col + 1;
+        }
+        // if the cell isn't empty, i.e. there is a number present in that cell
+        if (board[row][col] != '.') {
+            // do a recursive call, if the fn returns true, i.e. the board is solved,
+            // we'll also return true
+            if (helper(board, newRow, newCol))
+                return true;
+        }
+        // if cell is empty
+        else {
+            for (int i = 1; i <= 9; i++) {
+                // if it's safe to place 'i' at that cell
+                if (isValidPlacement(board, row, col, i)) {
+                    board[row][col] = (char) (i + '0');
+                    // after placing the number, do a recursive call,
+                    // if the fn returns true, we'll also return true
+                    if (helper(board, newRow, newCol))
+                        return true;
+                    // if the recursive call returns false, i.e. it wasn't safe to place 'i',
+                    // we'll empty the cell & and will try for the next value of 'i' (backtracking)
+                    else
+                        board[row][col] = '.';
+                }
+            }
+        }
+        // return false if it isn't posssible to place a number in the cell
+        return false;
+    }
+
+    // a utility fn to check for valid placement of a number in cell of Sudoku Board
+    boolean isValidPlacement(char[][] board, int row, int col, int number) {
+        // to check if 'number' is present in the row or the col
+        for (int i = 0; i < board.length; i++) {
+            // return false if 'number' is present in the col
+            if (board[i][col] == (char) (number + '0'))
+                return false;
+            // return false if 'number' is present in the row
+            if (board[row][i] == (char) (number + '0'))
+                return false;
+        }
+        // to check if the 'number' is present in the 3X3 grid
+        // There are two ways to get the initial row and column of 3X3 grid
+        // 1
+        int startingRow = (row / 3) * 3;
+        int startingCol = (col / 3) * 3;
+        // 2
+        // int startingRow = (row % 3) - row;
+        // int startingCol = (col % 3) - col;
+        for (int i = startingRow; i < startingRow + 3; i++)
+            for (int j = startingCol; j < startingCol + 3; j++)
+                // return false if 'number' is present in the 3X3 grid or matrix
+                if (board[i][j] == (char) (number + '0'))
+                    return false;
+        // return true if 'number' isn't present in row, col & grid
+        return true;
+    }
+}
+```
+
+### [_..._]()
+
+```
+
+```
+
+<!----------------------------------{ link }--------------------------------->
+
+[share]: https://img.icons8.com/external-anggara-blue-anggara-putra/20/000000/external-share-user-interface-basic-anggara-blue-anggara-putra-2.png
+[hard]: https://img.shields.io/badge/Difficulty-Hard-red.svg